Move Asterisk-addons modules into the main Asterisk source tree.

Someone asked yesterday, "is there a good reason why we can't just put these
modules in Asterisk?".  After a brief discussion, as long as the modules are
clearly set aside in their own directory and not enabled by default, it is
perfectly fine.

For more information about why a module goes in addons, see README-addons.txt.

chan_ooh323 does not currently compile as it is behind some trunk API updates.
However, it will not build by default, so it should be okay for now.


git-svn-id: http://svn.digium.com/svn/asterisk/trunk@204413 f38db490-d61c-443f-a65b-d21fe96a405b

93 files changed, 189612 insertions, 0 deletions

diff --git a/addons/Makefile b/addons/Makefile
new file mode 100644
index 000000000..c93759702
--- /dev/null
+++ b/addons/Makefile
@@ -0,0 +1,43 @@
+#
+# Asterisk -- A telephony toolkit for Linux.
+#
+# Makefile for Add-on Modules
+#
+# Copyright (C) 2009, Digium, Inc.
+#
+# This program is free software, distributed under the terms of
+# the GNU General Public License
+#
+
+-include $(ASTTOPDIR)/menuselect.makeopts $(ASTTOPDIR)/menuselect.makedeps
+
+MODULE_PREFIX=app bridge cdr cel chan codec format func pbx res test
+MENUSELECT_CATEGORY=Addons
+MENUSELECT_DESCRIPTION=Add-ons (See README-addons.txt)
+
+H323OBJS:=ooCmdChannel.o ooLogChan.o ooUtils.o ooGkClient.o context.o \
+	ooDateTime.o decode.o dlist.o encode.o errmgmt.o \
+	memheap.o ootrace.o oochannels.o ooh245.o ooports.o \
+	ooq931.o ooCapability.o ooSocket.o perutil.o eventHandler.o \
+	ooCalls.o ooStackCmds.o ooh323.o ooh323ep.o printHandler.o \
+	rtctype.o ooTimer.o h323/H235-SECURITY-MESSAGESDec.o \
+	h323/H235-SECURITY-MESSAGESEnc.o h323/H323-MESSAGES.o h323/H323-MESSAGESDec.o \
+	h323/H323-MESSAGESEnc.o h323/MULTIMEDIA-SYSTEM-CONTROL.o \
+	h323/MULTIMEDIA-SYSTEM-CONTROLDec.o h323/MULTIMEDIA-SYSTEM-CONTROLEnc.o
+
+H323CFLAGS:=-Iooh323c/src -Iooh323c/src/h323
+
+all: _all
+
+include $(ASTTOPDIR)/Makefile.moddir_rules
+
+clean::
+	$(MAKE) -C mp3 clean
+	rm -f $(addprefix ooh323c/src/,$(H323OBJS))
+
+$(if $(filter format_mp3,$(EMBEDDED_MODS)),modules.link,format_mp3.so): mp3/common.o mp3/dct64_i386.o mp3/decode_ntom.o mp3/layer3.o mp3/tabinit.o mp3/interface.o
+
+chan_ooh323.o: ASTCFLAGS+=$(H323CFLAGS)
+
+$(if $(filter chan_ooh323,$(EMBEDDED_MODS)),modules.link,chan_ooh323.so): ASTCFLAGS+=$(H323CFLAGS)
+$(if $(filter chan_ooh323,$(EMBEDDED_MODS)),modules.link,chan_ooh323.so): $(addprefix ooh323c/src/,$(H323OBJS)) chan_ooh323.o ooh323cDriver.o
diff --git a/addons/app_addon_sql_mysql.c b/addons/app_addon_sql_mysql.c
new file mode 100644
index 000000000..db33c11cb
--- /dev/null
+++ b/addons/app_addon_sql_mysql.c
@@ -0,0 +1,611 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2004, Constantine Filin and Christos Ricudis
+ *
+ * Christos Ricudis <ricudis@itc.auth.gr>
+ * Constantine Filin <cf@intermedia.net>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ * \brief MYSQL dialplan application
+ * \ingroup applications
+ */
+
+/*** MODULEINFO
+	<depend>mysqlclient</depend>
+	<defaultenabled>no</defaultenabled>
+ ***/
+
+#include "asterisk.h"
+
+#include <mysql/mysql.h>
+
+#include "asterisk/file.h"
+#include "asterisk/logger.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/module.h"
+#include "asterisk/linkedlists.h"
+#include "asterisk/chanvars.h"
+#include "asterisk/lock.h"
+#include "asterisk/options.h"
+#include "asterisk/app.h"
+#include "asterisk/config.h"
+
+#define EXTRA_LOG 0
+
+enum { NULLSTRING, NULLVALUE, EMPTYSTRING } nullvalue = NULLSTRING;
+
+static const char app[] = "MYSQL";
+
+static const char synopsis[] = "Do several mySQLy things";
+
+static const char descrip[] =
+"MYSQL():  Do several mySQLy things\n"
+"Syntax:\n"
+"  MYSQL(Set timeout <num>)\n"
+"    Set the connection timeout, in seconds.\n"
+"  MYSQL(Connect connid dhhost dbuser dbpass dbname)\n"
+"    Connects to a database.  Arguments contain standard MySQL parameters\n"
+"    passed to function mysql_real_connect.  Connection identifer returned\n"
+"    in ${connid}\n"
+"  MYSQL(Query resultid ${connid} query-string)\n"
+"    Executes standard MySQL query contained in query-string using established\n"
+"    connection identified by ${connid}. Result of query is stored in ${resultid}.\n"
+"  MYSQL(Nextresult resultid ${connid}\n"
+"    If last query returned more than one result set, it stores the next\n"
+"    result set in ${resultid}. It's useful with stored procedures\n"
+"  MYSQL(Fetch fetchid ${resultid} var1 var2 ... varN)\n"
+"    Fetches a single row from a result set contained in ${result_identifier}.\n"
+"    Assigns returned fields to ${var1} ... ${varn}.  ${fetchid} is set TRUE\n"
+"    if additional rows exist in result set.\n"
+"  MYSQL(Clear ${resultid})\n"
+"    Frees memory and datastructures associated with result set.\n"
+"  MYSQL(Disconnect ${connid})\n"
+"    Disconnects from named connection to MySQL.\n"
+"  On exit, always returns 0. Sets MYSQL_STATUS to 0 on success and -1 on error.\n";
+
+/*
+EXAMPLES OF USE :
+
+exten => s,2,MYSQL(Connect connid localhost asterisk mypass credit)
+exten => s,3,MYSQL(Query resultid ${connid} SELECT username,credit FROM credit WHERE callerid=${CALLERIDNUM})
+exten => s,4,MYSQL(Fetch fetchid ${resultid} datavar1 datavar2)
+exten => s,5,GotoIf(${fetchid}?6:8)
+exten => s,6,Festival("User ${datavar1} currently has credit balance of ${datavar2} dollars.")
+exten => s,7,Goto(s,4)
+exten => s,8,MYSQL(Clear ${resultid})
+exten => s,9,MYSQL(Disconnect ${connid})
+*/
+
+AST_MUTEX_DEFINE_STATIC(_mysql_mutex);
+
+#define MYSQL_CONFIG "mysql.conf"
+#define AST_MYSQL_ID_DUMMY   0
+#define AST_MYSQL_ID_CONNID  1
+#define AST_MYSQL_ID_RESID   2
+#define AST_MYSQL_ID_FETCHID 3
+
+static int autoclear = 0;
+
+static void mysql_ds_destroy(void *data);
+static void mysql_ds_fixup(void *data, struct ast_channel *oldchan, struct ast_channel *newchan);
+
+static struct ast_datastore_info mysql_ds_info = {
+	.type = "APP_ADDON_SQL_MYSQL",
+	.destroy = mysql_ds_destroy,
+	.chan_fixup = mysql_ds_fixup,
+};
+
+struct ast_MYSQL_id {
+	struct ast_channel *owner;
+	int identifier_type; /* 0=dummy, 1=connid, 2=resultid */
+	int identifier;
+	void *data;
+	AST_LIST_ENTRY(ast_MYSQL_id) entries;
+} *ast_MYSQL_id;
+
+AST_LIST_HEAD(MYSQLidshead,ast_MYSQL_id) _mysql_ids_head;
+
+static void mysql_ds_destroy(void *data)
+{
+	/* Destroy any IDs owned by the channel */
+	struct ast_MYSQL_id *i;
+	if (AST_LIST_LOCK(&_mysql_ids_head)) {
+		ast_log(LOG_WARNING, "Unable to lock identifiers list\n");
+	} else {
+		AST_LIST_TRAVERSE_SAFE_BEGIN(&_mysql_ids_head, i, entries) {
+			if (i->owner == data) {
+				AST_LIST_REMOVE_CURRENT(entries);
+				if (i->identifier_type == AST_MYSQL_ID_CONNID) {
+					/* Drop connection */
+					mysql_close(i->data);
+				} else if (i->identifier_type == AST_MYSQL_ID_RESID) {
+					/* Drop result */
+					mysql_free_result(i->data);
+				}
+				ast_free(i);
+			}
+		}
+		AST_LIST_TRAVERSE_SAFE_END
+		AST_LIST_UNLOCK(&_mysql_ids_head);
+	}
+}
+
+static void mysql_ds_fixup(void *data, struct ast_channel *oldchan, struct ast_channel *newchan)
+{
+	/* Destroy any IDs owned by the channel */
+	struct ast_MYSQL_id *i;
+	if (AST_LIST_LOCK(&_mysql_ids_head)) {
+		ast_log(LOG_WARNING, "Unable to lock identifiers list\n");
+	} else {
+		AST_LIST_TRAVERSE_SAFE_BEGIN(&_mysql_ids_head, i, entries) {
+			if (i->owner == data) {
+				AST_LIST_REMOVE_CURRENT(entries);
+				if (i->identifier_type == AST_MYSQL_ID_CONNID) {
+					/* Drop connection */
+					mysql_close(i->data);
+				} else if (i->identifier_type == AST_MYSQL_ID_RESID) {
+					/* Drop result */
+					mysql_free_result(i->data);
+				}
+				ast_free(i);
+			}
+		}
+		AST_LIST_TRAVERSE_SAFE_END
+		AST_LIST_UNLOCK(&_mysql_ids_head);
+	}
+}
+
+/* helpful procs */
+static void *find_identifier(int identifier, int identifier_type)
+{
+	struct MYSQLidshead *headp = &_mysql_ids_head;
+	struct ast_MYSQL_id *i;
+	void *res=NULL;
+	int found=0;
+
+	if (AST_LIST_LOCK(headp)) {
+		ast_log(LOG_WARNING, "Unable to lock identifiers list\n");
+	} else {
+		AST_LIST_TRAVERSE(headp, i, entries) {
+			if ((i->identifier == identifier) && (i->identifier_type == identifier_type)) {
+				found = 1;
+				res = i->data;
+				break;
+			}
+		}
+		if (!found) {
+			ast_log(LOG_WARNING, "Identifier %d, identifier_type %d not found in identifier list\n", identifier, identifier_type);
+		}
+		AST_LIST_UNLOCK(headp);
+	}
+
+	return res;
+}
+
+static int add_identifier(struct ast_channel *chan, int identifier_type, void *data)
+{
+	struct ast_MYSQL_id *i = NULL, *j = NULL;
+	struct MYSQLidshead *headp = &_mysql_ids_head;
+	int maxidentifier = 0;
+
+	if (AST_LIST_LOCK(headp)) {
+		ast_log(LOG_WARNING, "Unable to lock identifiers list\n");
+		return -1;
+	} else {
+		i = malloc(sizeof(*i));
+		AST_LIST_TRAVERSE(headp, j, entries) {
+			if (j->identifier > maxidentifier) {
+				maxidentifier = j->identifier;
+			}
+		}
+		i->identifier = maxidentifier + 1;
+		i->identifier_type = identifier_type;
+		i->data = data;
+		i->owner = chan;
+		AST_LIST_INSERT_HEAD(headp, i, entries);
+		AST_LIST_UNLOCK(headp);
+	}
+	return i->identifier;
+}
+
+static int del_identifier(int identifier, int identifier_type)
+{
+	struct ast_MYSQL_id *i;
+	struct MYSQLidshead *headp = &_mysql_ids_head;
+	int found = 0;
+
+	if (AST_LIST_LOCK(headp)) {
+		ast_log(LOG_WARNING, "Unable to lock identifiers list\n");
+	} else {
+		AST_LIST_TRAVERSE(headp, i, entries) {
+			if ((i->identifier == identifier) &&
+			    (i->identifier_type == identifier_type)) {
+				AST_LIST_REMOVE(headp, i, entries);
+				free(i);
+				found = 1;
+				break;
+			}
+		}
+		AST_LIST_UNLOCK(headp);
+	}
+
+	if (found == 0) {
+		ast_log(LOG_WARNING, "Could not find identifier %d, identifier_type %d in list to delete\n", identifier, identifier_type);
+		return -1;
+	} else {
+		return 0;
+	}
+}
+
+static int set_asterisk_int(struct ast_channel *chan, char *varname, int id)
+{
+	if (id >= 0) {
+		char s[12] = "";
+		snprintf(s, sizeof(s), "%d", id);
+		ast_debug(5, "MYSQL: setting var '%s' to value '%s'\n", varname, s);
+		pbx_builtin_setvar_helper(chan, varname, s);
+	}
+	return id;
+}
+
+static int add_identifier_and_set_asterisk_int(struct ast_channel *chan, char *varname, int identifier_type, void *data)
+{
+	return set_asterisk_int(chan, varname, add_identifier(chan, identifier_type, data));
+}
+
+static int safe_scan_int(char **data, char *delim, int def)
+{
+	char *end;
+	int res = def;
+	char *s = strsep(data, delim);
+	if (s) {
+		res = strtol(s, &end, 10);
+		if (*end)
+			res = def;  /* not an integer */
+	}
+	return res;
+}
+
+static int aMYSQL_set(struct ast_channel *chan, char *data)
+{
+	char *var, *tmp;
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(set);
+		AST_APP_ARG(variable);
+		AST_APP_ARG(value);
+	);
+
+	AST_NONSTANDARD_APP_ARGS(args, data, ' ');
+
+	if (args.argc == 3) {
+		var = alloca(6 + strlen(args.variable) + 1);
+		sprintf(var, "MYSQL_%s", args.variable);
+
+		/* Make the parameter case-insensitive */
+		for (tmp = var + 6; *tmp; tmp++)
+			*tmp = toupper(*tmp);
+
+		pbx_builtin_setvar_helper(chan, var, args.value);
+	}
+	return 0;
+}
+
+/* MYSQL operations */
+static int aMYSQL_connect(struct ast_channel *chan, char *data)
+{
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(connect);
+		AST_APP_ARG(connid);
+		AST_APP_ARG(dbhost);
+		AST_APP_ARG(dbuser);
+		AST_APP_ARG(dbpass);
+		AST_APP_ARG(dbname);
+	);
+	MYSQL *mysql;
+	int timeout;
+	const char *ctimeout;
+
+	AST_NONSTANDARD_APP_ARGS(args, data, ' ');
+
+	if (args.argc != 6) {
+		ast_log(LOG_WARNING, "MYSQL_connect is missing some arguments\n");
+		return -1;
+	}
+
+	if (!(mysql = mysql_init(NULL))) {
+		ast_log(LOG_WARNING, "mysql_init returned NULL\n");
+		return -1;
+	}
+
+	ctimeout = pbx_builtin_getvar_helper(chan, "MYSQL_TIMEOUT");
+	if (ctimeout && sscanf(ctimeout, "%d", &timeout) == 1) {
+		mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (void *)&timeout);
+	}
+
+	if (! mysql_real_connect(mysql, args.dbhost, args.dbuser, args.dbpass, args.dbname, 0, NULL,
+#ifdef CLIENT_MULTI_STATEMENTS
+			CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS
+#elif defined(CLIENT_MULTI_QUERIES)
+			CLIENT_MULTI_QUERIES
+#else
+			0
+#endif
+		)) {
+		ast_log(LOG_WARNING, "mysql_real_connect(mysql,%s,%s,dbpass,%s,...) failed(%d): %s\n",
+				args.dbhost, args.dbuser, args.dbname, mysql_errno(mysql), mysql_error(mysql));
+		return -1;
+	}
+
+	add_identifier_and_set_asterisk_int(chan, args.connid, AST_MYSQL_ID_CONNID, mysql);
+	return 0;
+}
+
+static int aMYSQL_query(struct ast_channel *chan, char *data)
+{
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(query);
+		AST_APP_ARG(resultid);
+		AST_APP_ARG(connid);
+		AST_APP_ARG(sql);
+	);
+	MYSQL       *mysql;
+	MYSQL_RES   *mysqlres;
+	int connid;
+	int mysql_query_res;
+
+	AST_NONSTANDARD_APP_ARGS(args, data, ' ');
+
+	if (args.argc != 4 || (connid = atoi(args.connid)) == 0) {
+		ast_log(LOG_WARNING, "missing some arguments\n");
+		return -1;
+	}
+
+	if (!(mysql = find_identifier(connid, AST_MYSQL_ID_CONNID))) {
+		ast_log(LOG_WARNING, "Invalid connection identifier %s passed in aMYSQL_query\n", args.connid);
+		return -1;
+	}
+
+	if ((mysql_query_res = mysql_query(mysql, args.sql)) != 0) {
+		ast_log(LOG_WARNING, "aMYSQL_query: mysql_query failed. Error: %s\n", mysql_error(mysql));
+		return -1;
+	}
+
+	if ((mysqlres = mysql_store_result(mysql))) {
+		add_identifier_and_set_asterisk_int(chan, args.resultid, AST_MYSQL_ID_RESID, mysqlres);
+		return 0;
+	} else if (!mysql_field_count(mysql)) {
+		return 0;
+	} else
+		ast_log(LOG_WARNING, "mysql_store_result() failed on query %s\n", args.sql);
+
+	return -1;
+}
+
+static int aMYSQL_nextresult(struct ast_channel *chan, char *data)
+{
+	MYSQL       *mysql;
+	MYSQL_RES   *mysqlres;
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(nextresult);
+		AST_APP_ARG(resultid);
+		AST_APP_ARG(connid);
+	);
+	int connid = -1;
+
+	AST_NONSTANDARD_APP_ARGS(args, data, ' ');
+	sscanf(args.connid, "%d", &connid);
+
+	if (args.argc != 3 || connid <= 0) {
+		ast_log(LOG_WARNING, "missing some arguments\n");
+		return -1;
+	}
+
+	if (!(mysql = find_identifier(connid, AST_MYSQL_ID_CONNID))) {
+		ast_log(LOG_WARNING, "Invalid connection identifier %d passed in aMYSQL_query\n", connid);
+		return -1;
+	}
+
+	if (mysql_more_results(mysql)) {
+		mysql_next_result(mysql);
+		if ((mysqlres = mysql_store_result(mysql))) {
+			add_identifier_and_set_asterisk_int(chan, args.resultid, AST_MYSQL_ID_RESID, mysqlres);
+			return 0;
+		} else if (!mysql_field_count(mysql)) {
+			return 0;
+		} else
+			ast_log(LOG_WARNING, "mysql_store_result() failed on storing next_result\n");
+	} else
+		ast_log(LOG_WARNING, "mysql_more_results() result set has no more results\n");
+
+	return 0;
+}
+
+
+static int aMYSQL_fetch(struct ast_channel *chan, char *data)
+{
+	MYSQL_RES *mysqlres;
+	MYSQL_ROW mysqlrow;
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(fetch);
+		AST_APP_ARG(resultvar);
+		AST_APP_ARG(fetchid);
+		AST_APP_ARG(vars);
+	);
+	char *s5, *parse;
+	int resultid = -1, numFields, j;
+
+	parse = ast_strdupa(data);
+	AST_NONSTANDARD_APP_ARGS(args, parse, ' ');
+	sscanf(args.fetchid, "%d", &resultid);
+
+	if (args.resultvar && (resultid >= 0) ) {
+		if ((mysqlres = find_identifier(resultid, AST_MYSQL_ID_RESID)) != NULL) {
+			/* Grab the next row */
+			if ((mysqlrow = mysql_fetch_row(mysqlres)) != NULL) {
+				numFields = mysql_num_fields(mysqlres);
+				for (j = 0; j < numFields; j++) {
+					s5 = strsep(&args.vars, " ");
+					if (s5 == NULL) {
+						ast_log(LOG_WARNING, "ast_MYSQL_fetch: More fields (%d) than variables (%d)\n", numFields, j);
+						break;
+					}
+
+					pbx_builtin_setvar_helper(chan, s5, mysqlrow[j] ? mysqlrow[j] :
+						nullvalue == NULLSTRING ? "NULL" :
+						nullvalue == EMPTYSTRING ? "" :
+						NULL);
+				}
+				ast_debug(5, "ast_MYSQL_fetch: numFields=%d\n", numFields);
+				set_asterisk_int(chan, args.resultvar, 1); /* try more rows */
+			} else {
+				ast_debug(5, "ast_MYSQL_fetch : EOF\n");
+				set_asterisk_int(chan, args.resultvar, 0); /* no more rows */
+			}
+			return 0;
+		} else {
+			set_asterisk_int(chan, args.resultvar, 0);
+			ast_log(LOG_WARNING, "aMYSQL_fetch: Invalid result identifier %d passed\n", resultid);
+		}
+	} else {
+		ast_log(LOG_WARNING, "aMYSQL_fetch: missing some arguments\n");
+	}
+
+	return -1;
+}
+
+static int aMYSQL_clear(struct ast_channel *chan, char *data)
+{
+	MYSQL_RES *mysqlres;
+
+	int id;
+	strsep(&data, " "); /* eat the first token, we already know it :P */
+	id = safe_scan_int(&data, " \n", -1);
+	if ((mysqlres = find_identifier(id, AST_MYSQL_ID_RESID)) == NULL) {
+		ast_log(LOG_WARNING, "Invalid result identifier %d passed in aMYSQL_clear\n", id);
+	} else {
+		mysql_free_result(mysqlres);
+		del_identifier(id, AST_MYSQL_ID_RESID);
+	}
+
+	return 0;
+}
+
+static int aMYSQL_disconnect(struct ast_channel *chan, char *data)
+{
+	MYSQL *mysql;
+	int id;
+	strsep(&data, " "); /* eat the first token, we already know it :P */
+
+	id = safe_scan_int(&data, " \n", -1);
+	if ((mysql = find_identifier(id, AST_MYSQL_ID_CONNID)) == NULL) {
+		ast_log(LOG_WARNING, "Invalid connection identifier %d passed in aMYSQL_disconnect\n", id);
+	} else {
+		mysql_close(mysql);
+		del_identifier(id, AST_MYSQL_ID_CONNID);
+	}
+
+	return 0;
+}
+
+static int MYSQL_exec(struct ast_channel *chan, const char *data)
+{
+	int result;
+	char sresult[10];
+
+	ast_debug(5, "MYSQL: data=%s\n", data);
+
+	if (!data) {
+		ast_log(LOG_WARNING, "MYSQL requires an argument (see manual)\n");
+		return -1;
+	}
+
+	result = 0;
+
+	if (autoclear) {
+		struct ast_datastore *mysql_store = ast_channel_datastore_find(chan, &mysql_ds_info, NULL);
+		if (!mysql_store) {
+			if (!(mysql_store = ast_datastore_alloc(&mysql_ds_info, NULL))) {
+				ast_log(LOG_WARNING, "Unable to allocate new datastore.\n");
+			} else {
+				mysql_store->data = chan;
+				ast_channel_datastore_add(chan, mysql_store);
+			}
+		}
+	}
+	ast_mutex_lock(&_mysql_mutex);
+
+	if (strncasecmp("connect", data, strlen("connect")) == 0) {
+		result = aMYSQL_connect(chan, ast_strdupa(data));
+	} else if (strncasecmp("query", data, strlen("query")) == 0) {
+		result = aMYSQL_query(chan, ast_strdupa(data));
+	} else if (strncasecmp("nextresult", data, strlen("nextresult")) == 0) {
+		result = aMYSQL_nextresult(chan, ast_strdupa(data));
+	} else if (strncasecmp("fetch", data, strlen("fetch")) == 0) {
+		result = aMYSQL_fetch(chan, ast_strdupa(data));
+	} else if (strncasecmp("clear", data, strlen("clear")) == 0) {
+		result = aMYSQL_clear(chan, ast_strdupa(data));
+	} else if (strncasecmp("disconnect", data, strlen("disconnect")) == 0) {
+		result = aMYSQL_disconnect(chan, ast_strdupa(data));
+	} else if (strncasecmp("set", data, 3) == 0) {
+		result = aMYSQL_set(chan, ast_strdupa(data));
+	} else {
+		ast_log(LOG_WARNING, "Unknown argument to MYSQL application : %s\n", data);
+		result = -1;
+	}
+
+	ast_mutex_unlock(&_mysql_mutex);
+
+	snprintf(sresult, sizeof(sresult), "%d", result);
+	pbx_builtin_setvar_helper(chan, "MYSQL_STATUS", sresult);
+	return 0;
+}
+
+static int unload_module(void)
+{
+	return ast_unregister_application(app);
+}
+
+static int load_module(void)
+{
+	struct MYSQLidshead *headp = &_mysql_ids_head;
+	struct ast_flags config_flags = { 0 };
+	struct ast_config *cfg = ast_config_load(MYSQL_CONFIG, config_flags);
+	const char *temp;
+
+	if (cfg) {
+		if ((temp = ast_variable_retrieve(cfg, "general", "nullvalue"))) {
+			if (!strcasecmp(temp, "nullstring")) {
+				nullvalue = NULLSTRING;
+			} else if (!strcasecmp(temp, "emptystring")) {
+				nullvalue = EMPTYSTRING;
+			} else if (!strcasecmp(temp, "null")) {
+				nullvalue = NULLVALUE;
+			} else {
+				ast_log(LOG_WARNING, "Illegal value for 'nullvalue': '%s' (must be 'nullstring', 'null', or 'emptystring')\n", temp);
+			}
+		}
+		if ((temp = ast_variable_retrieve(cfg, "general", "autoclear")) && ast_true(temp)) {
+			autoclear = 1;
+		}
+		ast_config_destroy(cfg);
+	}
+
+	AST_LIST_HEAD_INIT(headp);
+	return ast_register_application(app, MYSQL_exec, synopsis, descrip);
+}
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Simple Mysql Interface");
diff --git a/addons/app_saycountpl.c b/addons/app_saycountpl.c
new file mode 100644
index 000000000..fd921de1a
--- /dev/null
+++ b/addons/app_saycountpl.c
@@ -0,0 +1,136 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2004, Andy Powell & TAAN Softworks Corp. 
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ * \brief Say Polish counting words
+ * \author Andy Powell
+ */
+
+/*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/file.h"
+#include "asterisk/logger.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/module.h"
+#include "asterisk/lock.h"
+#include "asterisk/app.h"
+
+/*** DOCUMENTATION
+	<application name="SayCountPL" language="en_US">
+		<synopsis>
+			Say Polish counting words.
+		</synopsis>
+		<syntax>
+			<parameter name="word1" required="true" />
+			<parameter name="word2" required="true" />
+			<parameter name="word5" required="true" />
+			<parameter name="number" required="true" />
+		</syntax>
+		<description>
+			<para>Polish grammar has some funny rules for counting words. for example 1 zloty,
+			2 zlote, 5 zlotych. This application will take the words for 1, 2-4 and 5 and
+			decide based on grammar rules which one to use with the number you pass to it.</para>
+			<para>Example: SayCountPL(zloty,zlote,zlotych,122) will give: zlote</para>
+		</description>
+	</application>
+
+ ***/
+static const char app[] = "SayCountPL";
+
+static int saywords(struct ast_channel *chan, char *word1, char *word2, char *word5, int num)
+{
+	/* Put this in a separate proc because it's bound to change */
+	int d = 0;
+
+	if (num > 0) {
+		if (num % 1000 == 1) {
+			ast_streamfile(chan, word1, chan->language);
+			d = ast_waitstream(chan,"");
+		} else if (((num % 10) >= 2) && ((num % 10) <= 4 ) && ((num % 100) < 10 || (num % 100) > 20)) {
+			ast_streamfile(chan, word2, chan->language);
+			d = ast_waitstream(chan, "");
+		} else {
+			ast_streamfile(chan, word5, chan->language);
+			d = ast_waitstream(chan, "");
+		}
+	}
+
+	return d;
+}
+
+
+static int sayword_exec(struct ast_channel *chan, const char *data)
+{
+	int res = 0;
+	char *s;
+	int inum;
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(word1);
+		AST_APP_ARG(word2);
+		AST_APP_ARG(word5);
+		AST_APP_ARG(num);
+	);
+
+	if (!data) {
+		ast_log(LOG_WARNING, "SayCountPL requires 4 arguments: word-1,word-2,word-5,number\n");
+		return -1;
+	}
+
+	s = ast_strdupa(data);
+
+	AST_STANDARD_APP_ARGS(args, s);
+
+	/* Check to see if params passed */
+	if (!args.word1 || !args.word2 || !args.word5 || !args.num) {
+		ast_log(LOG_WARNING, "SayCountPL requires 4 arguments: word-1,word-2,word-3,number\n");
+		return -1;
+	}
+
+	if (sscanf(args.num, "%d", &inum) != 1) {
+		ast_log(LOG_WARNING, "'%s' is not a valid number\n", args.num);
+		return -1;
+	}
+
+	/* do the saying part (after a bit of maths) */
+
+	res = saywords(chan, args.word1, args.word2, args.word5, inum);
+
+	return res;
+}
+
+static int unload_module(void)
+{
+	return ast_unregister_application(app);
+}
+
+static int load_module(void)
+{
+	int res;
+
+	res = ast_register_application_xml(app, sayword_exec);
+
+	return res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS;
+}
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Say polish counting words");
diff --git a/addons/cdr_addon_mysql.c b/addons/cdr_addon_mysql.c
new file mode 100644
index 000000000..2a3ef4365
--- /dev/null
+++ b/addons/cdr_addon_mysql.c
@@ -0,0 +1,641 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * James Sharp <jsharp@psychoses.org>
+ *
+ * Modified August 2003
+ * Tilghman Lesher <asterisk__cdr__cdr_mysql__200308@the-tilghman.com>
+ *
+ * Modified August 6, 2005
+ * Joseph Benden <joe@thrallingpenguin.com>
+ * Added mysql connection timeout parameter
+ * Added an automatic reconnect as to not lose a cdr record
+ * Cleaned up the original code to match the coding guidelines
+ *
+ * Modified Juli 2006
+ * Martin Portmann <map@infinitum.ch>
+ * Added mysql ssl support
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ * \brief MySQL CDR backend
+ * \ingroup cdr_drivers
+ */
+
+/*** MODULEINFO
+	<depend>mysqlclient</depend>
+	<defaultenabled>no</defaultenabled>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <mysql/mysql.h>
+#include <mysql/errmsg.h>
+
+#include "asterisk/config.h"
+#include "asterisk/options.h"
+#include "asterisk/channel.h"
+#include "asterisk/cdr.h"
+#include "asterisk/module.h"
+#include "asterisk/logger.h"
+#include "asterisk/cli.h"
+#include "asterisk/strings.h"
+#include "asterisk/linkedlists.h"
+#include "asterisk/threadstorage.h"
+
+#define DATE_FORMAT "%Y-%m-%d %T"
+
+AST_THREADSTORAGE(sql1_buf);
+AST_THREADSTORAGE(sql2_buf);
+AST_THREADSTORAGE(escape_buf);
+
+static const char desc[] = "MySQL CDR Backend";
+static const char name[] = "mysql";
+static const char config[] = "cdr_mysql.conf";
+
+static struct ast_str *hostname = NULL, *dbname = NULL, *dbuser = NULL, *password = NULL, *dbsock = NULL, *dbtable = NULL, *dbcharset = NULL;
+
+static struct ast_str *ssl_ca = NULL, *ssl_cert = NULL, *ssl_key = NULL;
+
+static int dbport = 0;
+static int connected = 0;
+static time_t connect_time = 0;
+static int records = 0;
+static int totalrecords = 0;
+static int timeout = 0;
+static int calldate_compat = 0;
+
+AST_MUTEX_DEFINE_STATIC(mysql_lock);
+
+struct unload_string {
+	AST_LIST_ENTRY(unload_string) entry;
+	struct ast_str *str;
+};
+
+static AST_LIST_HEAD_STATIC(unload_strings, unload_string);
+
+struct column {
+	char *name;
+	char *cdrname;
+	char *staticvalue;
+	char *type;
+	AST_LIST_ENTRY(column) list;
+};
+
+/* Protected with mysql_lock */
+static AST_RWLIST_HEAD_STATIC(columns, column);
+
+static MYSQL mysql = { { NULL }, };
+
+static char *handle_cli_cdr_mysql_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "cdr mysql status";
+		e->usage =
+			"Usage: cdr mysql status\n"
+			"       Shows current connection status for cdr_mysql\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 3)
+		return CLI_SHOWUSAGE;
+
+	if (connected) {
+		char status[256], status2[100] = "";
+		int ctime = time(NULL) - connect_time;
+		if (dbport)
+			snprintf(status, 255, "Connected to %s@%s, port %d", ast_str_buffer(dbname), ast_str_buffer(hostname), dbport);
+		else if (dbsock)
+			snprintf(status, 255, "Connected to %s on socket file %s", ast_str_buffer(dbname), S_OR(ast_str_buffer(dbsock), "default"));
+		else
+			snprintf(status, 255, "Connected to %s@%s", ast_str_buffer(dbname), ast_str_buffer(hostname));
+
+		if (!ast_strlen_zero(ast_str_buffer(dbuser)))
+			snprintf(status2, 99, " with username %s", ast_str_buffer(dbuser));
+		if (ast_str_strlen(dbtable))
+			snprintf(status2, 99, " using table %s", ast_str_buffer(dbtable));
+		if (ctime > 31536000) {
+			ast_cli(a->fd, "%s%s for %d years, %d days, %d hours, %d minutes, %d seconds.\n", status, status2, ctime / 31536000, (ctime % 31536000) / 86400, (ctime % 86400) / 3600, (ctime % 3600) / 60, ctime % 60);
+		} else if (ctime > 86400) {
+			ast_cli(a->fd, "%s%s for %d days, %d hours, %d minutes, %d seconds.\n", status, status2, ctime / 86400, (ctime % 86400) / 3600, (ctime % 3600) / 60, ctime % 60);
+		} else if (ctime > 3600) {
+			ast_cli(a->fd, "%s%s for %d hours, %d minutes, %d seconds.\n", status, status2, ctime / 3600, (ctime % 3600) / 60, ctime % 60);
+		} else if (ctime > 60) {
+			ast_cli(a->fd, "%s%s for %d minutes, %d seconds.\n", status, status2, ctime / 60, ctime % 60);
+		} else {
+			ast_cli(a->fd, "%s%s for %d seconds.\n", status, status2, ctime);
+		}
+		if (records == totalrecords)
+			ast_cli(a->fd, "  Wrote %d records since last restart.\n", totalrecords);
+		else
+			ast_cli(a->fd, "  Wrote %d records since last restart and %d records since last reconnect.\n", totalrecords, records);
+	} else {
+		ast_cli(a->fd, "Not currently connected to a MySQL server.\n");
+	}
+
+	return CLI_SUCCESS;
+}
+
+static struct ast_cli_entry cdr_mysql_status_cli[] = {
+	AST_CLI_DEFINE(handle_cli_cdr_mysql_status, "Show connection status of cdr_mysql"),
+};
+
+static int mysql_log(struct ast_cdr *cdr)
+{
+	struct ast_str *sql1 = ast_str_thread_get(&sql1_buf, 1024), *sql2 = ast_str_thread_get(&sql2_buf, 1024);
+	int retries = 5;
+#if MYSQL_VERSION_ID >= 50013
+	my_bool my_bool_true = 1;
+#endif
+
+	if (!sql1 || !sql2) {
+		ast_log(LOG_ERROR, "Memory error\n");
+		return -1;
+	}
+
+	ast_mutex_lock(&mysql_lock);
+
+db_reconnect:
+	if ((!connected) && (hostname || dbsock) && dbuser && password && dbname && dbtable ) {
+		/* Attempt to connect */
+		mysql_init(&mysql);
+		/* Add option to quickly timeout the connection */
+		if (timeout && mysql_options(&mysql, MYSQL_OPT_CONNECT_TIMEOUT, (char *)&timeout) != 0) {
+			ast_log(LOG_ERROR, "mysql_options returned (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql));
+		}
+#if MYSQL_VERSION_ID >= 50013
+		/* Add option for automatic reconnection */
+		if (mysql_options(&mysql, MYSQL_OPT_RECONNECT, &my_bool_true) != 0) {
+			ast_log(LOG_ERROR, "mysql_options returned (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql));
+		}
+#endif
+		if (ssl_ca || ssl_cert || ssl_key) {
+			mysql_ssl_set(&mysql, ssl_key ? ast_str_buffer(ssl_key) : NULL, ssl_cert ? ast_str_buffer(ssl_cert) : NULL, ssl_ca ? ast_str_buffer(ssl_ca) : NULL, NULL, NULL);
+		}
+		if (mysql_real_connect(&mysql, ast_str_buffer(hostname), ast_str_buffer(dbuser), ast_str_buffer(password), ast_str_buffer(dbname), dbport, dbsock && ast_str_strlen(dbsock) ? ast_str_buffer(dbsock) : NULL, ssl_ca ? CLIENT_SSL : 0)) {
+			connected = 1;
+			connect_time = time(NULL);
+			records = 0;
+			if (dbcharset) {
+				ast_str_set(&sql1, 0, "SET NAMES '%s'", ast_str_buffer(dbcharset));
+				mysql_real_query(&mysql, ast_str_buffer(sql1), ast_str_strlen(sql1));
+				ast_debug(1, "SQL command as follows: %s\n", ast_str_buffer(sql1));
+			}
+		} else {
+			ast_log(LOG_ERROR, "Cannot connect to database server %s: (%d) %s\n", ast_str_buffer(hostname), mysql_errno(&mysql), mysql_error(&mysql));
+			connected = 0;
+		}
+	} else {
+		/* Long connection - ping the server */
+		int error;
+		if ((error = mysql_ping(&mysql))) {
+			connected = 0;
+			records = 0;
+			switch (mysql_errno(&mysql)) {
+				case CR_SERVER_GONE_ERROR:
+				case CR_SERVER_LOST:
+					ast_log(LOG_ERROR, "Server has gone away. Attempting to reconnect.\n");
+					break;
+				default:
+					ast_log(LOG_ERROR, "Unknown connection error: (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql));
+			}
+			retries--;
+			if (retries) {
+				goto db_reconnect;
+			} else {
+				ast_log(LOG_ERROR, "Retried to connect five times, giving up.\n");
+			}
+		}
+	}
+
+	if (connected) {
+		int column_count = 0;
+		char *cdrname;
+		char workspace[2048], *value = NULL;
+		struct column *entry;
+		struct ast_str *escape = ast_str_thread_get(&escape_buf, 16);
+
+		ast_str_set(&sql1, 0, "INSERT INTO %s (", AS_OR(dbtable, "cdr"));
+		ast_str_set(&sql2, 0, ") VALUES (");
+
+		AST_RWLIST_RDLOCK(&columns);
+		AST_RWLIST_TRAVERSE(&columns, entry, list) {
+			if (!strcmp(entry->name, "calldate")) {
+				/*!\note
+				 * For some dumb reason, "calldate" used to be formulated using
+				 * the datetime the record was posted, rather than the start
+				 * time of the call.  If someone really wants the old compatible
+				 * behavior, it's provided here.
+				 */
+				if (calldate_compat) {
+					struct timeval tv = ast_tvnow();
+					struct ast_tm tm;
+					char timestr[128];
+					ast_localtime(&tv, &tm, NULL);
+					ast_strftime(timestr, sizeof(timestr), "%Y-%m-%d %T", &tm);
+					ast_cdr_setvar(cdr, "calldate", timestr, 0);
+					cdrname = "calldate";
+				} else {
+					cdrname = "start";
+				}
+			} else {
+				cdrname = entry->cdrname;
+			}
+
+			/* Construct SQL */
+
+			/* Need the type and value to determine if we want the raw value or not */
+			if (entry->staticvalue) {
+				value = ast_strdupa(entry->staticvalue);
+			} else if ((!strcmp(cdrname, "start") ||
+				 !strcmp(cdrname, "answer") ||
+				 !strcmp(cdrname, "end") ||
+				 !strcmp(cdrname, "disposition") ||
+				 !strcmp(cdrname, "amaflags")) &&
+				(strstr(entry->type, "int") ||
+				 strstr(entry->type, "dec") ||
+				 strstr(entry->type, "float") ||
+				 strstr(entry->type, "double") ||
+				 strstr(entry->type, "real") ||
+				 strstr(entry->type, "numeric") ||
+				 strstr(entry->type, "fixed"))) {
+				ast_cdr_getvar(cdr, cdrname, &value, workspace, sizeof(workspace), 0, 1);
+			} else {
+				ast_cdr_getvar(cdr, cdrname, &value, workspace, sizeof(workspace), 0, 0);
+			}
+
+			if (value) {
+				size_t valsz;
+
+				if (column_count++) {
+					ast_str_append(&sql1, 0, ",");
+					ast_str_append(&sql2, 0, ",");
+				}
+
+				ast_str_make_space(&escape, (valsz = strlen(value)) * 2 + 1);
+				mysql_real_escape_string(&mysql, ast_str_buffer(escape), value, valsz);
+
+				ast_str_append(&sql1, 0, "%s", entry->name);
+				ast_str_append(&sql2, 0, "'%s'", ast_str_buffer(escape));
+			}
+		}
+		AST_RWLIST_UNLOCK(&columns);
+
+		ast_debug(1, "Inserting a CDR record.\n");
+		ast_str_append(&sql1, 0, "%s)", ast_str_buffer(sql2));
+
+		ast_debug(1, "SQL command as follows: %s\n", ast_str_buffer(sql1));
+
+		if (mysql_real_query(&mysql, ast_str_buffer(sql1), ast_str_strlen(sql1))) {
+			ast_log(LOG_ERROR, "Failed to insert into database: (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql));
+			mysql_close(&mysql);
+			connected = 0;
+		} else {
+			records++;
+			totalrecords++;
+		}
+	}
+	ast_mutex_unlock(&mysql_lock);
+	return 0;
+}
+
+static int my_unload_module(int reload)
+{ 
+	struct unload_string *us;
+	struct column *entry;
+
+	ast_cli_unregister_multiple(cdr_mysql_status_cli, sizeof(cdr_mysql_status_cli) / sizeof(struct ast_cli_entry));
+
+	if (connected) {
+		mysql_close(&mysql);
+		connected = 0;
+		records = 0;
+	}
+
+	AST_LIST_LOCK(&unload_strings);
+	while ((us = AST_LIST_REMOVE_HEAD(&unload_strings, entry))) {
+		ast_free(us->str);
+		ast_free(us);
+	}
+	AST_LIST_UNLOCK(&unload_strings);
+
+	if (!reload) {
+		AST_RWLIST_WRLOCK(&columns);
+	}
+	while ((entry = AST_RWLIST_REMOVE_HEAD(&columns, list))) {
+		ast_free(entry);
+	}
+	if (!reload) {
+		AST_RWLIST_UNLOCK(&columns);
+	}
+
+	dbport = 0;
+	ast_cdr_unregister(name);
+	
+	return 0;
+}
+
+static int my_load_config_string(struct ast_config *cfg, const char *category, const char *variable, struct ast_str **field, const char *def)
+{
+	struct unload_string *us;
+	const char *tmp;
+
+	if (!(us = ast_calloc(1, sizeof(*us))))
+		return -1;
+
+	if (!(*field = ast_str_create(16))) {
+		ast_free(us);
+		return -1;
+	}
+
+	us->str = *field;
+
+	AST_LIST_LOCK(&unload_strings);
+	AST_LIST_INSERT_HEAD(&unload_strings, us, entry);
+	AST_LIST_UNLOCK(&unload_strings);
+
+	tmp = ast_variable_retrieve(cfg, category, variable);
+
+	ast_str_set(field, 0, "%s", tmp ? tmp : def);
+
+	return 0;
+}
+
+static int my_load_config_number(struct ast_config *cfg, const char *category, const char *variable, int *field, int def)
+{
+	const char *tmp;
+
+	tmp = ast_variable_retrieve(cfg, category, variable);
+
+	if (!tmp || sscanf(tmp, "%d", field) < 1)
+		*field = def;
+
+	return 0;
+}
+
+static int my_load_module(int reload)
+{
+	int res;
+	struct ast_config *cfg;
+	struct ast_variable *var;
+	struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
+	struct column *entry;
+	char *temp;
+	struct ast_str *compat;
+	MYSQL_ROW row;
+	MYSQL_RES *result;
+	char sqldesc[128];
+#if MYSQL_VERSION_ID >= 50013
+	my_bool my_bool_true = 1;
+#endif
+
+	cfg = ast_config_load(config, config_flags);
+	if (!cfg) {
+		ast_log(LOG_WARNING, "Unable to load config for mysql CDR's: %s\n", config);
+		return AST_MODULE_LOAD_SUCCESS;
+	} else if (cfg == CONFIG_STATUS_FILEUNCHANGED)
+		return AST_MODULE_LOAD_SUCCESS;
+
+	if (reload) {
+		AST_RWLIST_WRLOCK(&columns);
+		my_unload_module(1);
+	}
+
+	var = ast_variable_browse(cfg, "global");
+	if (!var) {
+		/* nothing configured */
+		if (reload) {
+			AST_RWLIST_UNLOCK(&columns);
+		}
+		return AST_MODULE_LOAD_SUCCESS;
+	}
+
+	res = 0;
+
+	res |= my_load_config_string(cfg, "global", "hostname", &hostname, "localhost");
+	res |= my_load_config_string(cfg, "global", "dbname", &dbname, "astriskcdrdb");
+	res |= my_load_config_string(cfg, "global", "user", &dbuser, "root");
+	res |= my_load_config_string(cfg, "global", "sock", &dbsock, "");
+	res |= my_load_config_string(cfg, "global", "table", &dbtable, "cdr");
+	res |= my_load_config_string(cfg, "global", "password", &password, "");
+
+	res |= my_load_config_string(cfg, "global", "charset", &dbcharset, "");
+
+	res |= my_load_config_string(cfg, "global", "ssl_ca", &ssl_ca, "");
+	res |= my_load_config_string(cfg, "global", "ssl_cert", &ssl_cert, "");
+	res |= my_load_config_string(cfg, "global", "ssl_key", &ssl_key, "");
+
+	res |= my_load_config_number(cfg, "global", "port", &dbport, 0);
+	res |= my_load_config_number(cfg, "global", "timeout", &timeout, 0);
+	res |= my_load_config_string(cfg, "global", "compat", &compat, "no");
+	if (ast_true(ast_str_buffer(compat))) {
+		calldate_compat = 1;
+	} else {
+		calldate_compat = 0;
+	}
+
+	if (res < 0) {
+		if (reload) {
+			AST_RWLIST_UNLOCK(&columns);
+		}
+		return AST_MODULE_LOAD_FAILURE;
+	}
+
+	/* Check for any aliases */
+	if (!reload) {
+		/* Lock, if not already */
+		AST_RWLIST_WRLOCK(&columns);
+	}
+	while ((entry = AST_LIST_REMOVE_HEAD(&columns, list))) {
+		ast_free(entry);
+	}
+
+	ast_debug(1, "Got hostname of %s\n", ast_str_buffer(hostname));
+	ast_debug(1, "Got port of %d\n", dbport);
+	ast_debug(1, "Got a timeout of %d\n", timeout);
+	if (dbsock)
+		ast_debug(1, "Got sock file of %s\n", ast_str_buffer(dbsock));
+	ast_debug(1, "Got user of %s\n", ast_str_buffer(dbuser));
+	ast_debug(1, "Got dbname of %s\n", ast_str_buffer(dbname));
+	ast_debug(1, "Got password of %s\n", ast_str_buffer(password));
+	ast_debug(1, "%sunning in calldate compatibility mode\n", calldate_compat ? "R" : "Not r");
+
+	if (dbcharset) {
+		ast_debug(1, "Got DB charset of %s\n", ast_str_buffer(dbcharset));
+	}
+
+	mysql_init(&mysql);
+
+	if (timeout && mysql_options(&mysql, MYSQL_OPT_CONNECT_TIMEOUT, (char *)&timeout) != 0) {
+		ast_log(LOG_ERROR, "cdr_mysql: mysql_options returned (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql));
+	}
+
+#if MYSQL_VERSION_ID >= 50013
+	/* Add option for automatic reconnection */
+	if (mysql_options(&mysql, MYSQL_OPT_RECONNECT, &my_bool_true) != 0) {
+		ast_log(LOG_ERROR, "cdr_mysql: mysql_options returned (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql));
+	}
+#endif
+
+	if ((ssl_ca && ast_str_strlen(ssl_ca)) || (ssl_cert && ast_str_strlen(ssl_cert)) || (ssl_key && ast_str_strlen(ssl_key))) {
+		mysql_ssl_set(&mysql,
+			ssl_key ? ast_str_buffer(ssl_key) : NULL,
+			ssl_cert ? ast_str_buffer(ssl_cert) : NULL,
+			ssl_ca ? ast_str_buffer(ssl_ca) : NULL,
+			NULL, NULL);
+	}
+	temp = dbsock && ast_str_strlen(dbsock) ? ast_str_buffer(dbsock) : NULL;
+	if (!mysql_real_connect(&mysql, ast_str_buffer(hostname), ast_str_buffer(dbuser), ast_str_buffer(password), ast_str_buffer(dbname), dbport, temp, ssl_ca && ast_str_strlen(ssl_ca) ? CLIENT_SSL : 0)) {
+		ast_log(LOG_ERROR, "Failed to connect to mysql database %s on %s.\n", ast_str_buffer(dbname), ast_str_buffer(hostname));
+		connected = 0;
+		records = 0;
+	} else {
+		ast_debug(1, "Successfully connected to MySQL database.\n");
+		connected = 1;
+		records = 0;
+		connect_time = time(NULL);
+		if (dbcharset) {
+			snprintf(sqldesc, sizeof(sqldesc), "SET NAMES '%s'", ast_str_buffer(dbcharset));
+			mysql_real_query(&mysql, sqldesc, strlen(sqldesc));
+			ast_debug(1, "SQL command as follows: %s\n", sqldesc);
+		}
+
+		/* Get table description */
+		snprintf(sqldesc, sizeof(sqldesc), "DESC %s", dbtable ? ast_str_buffer(dbtable) : "cdr");
+		if (mysql_query(&mysql, sqldesc)) {
+			ast_log(LOG_ERROR, "Unable to query table description!!  Logging disabled.\n");
+			mysql_close(&mysql);
+			connected = 0;
+			AST_RWLIST_UNLOCK(&columns);
+			ast_config_destroy(cfg);
+			return AST_MODULE_LOAD_SUCCESS;
+		}
+
+		if (!(result = mysql_store_result(&mysql))) {
+			ast_log(LOG_ERROR, "Unable to query table description!!  Logging disabled.\n");
+			mysql_close(&mysql);
+			connected = 0;
+			AST_RWLIST_UNLOCK(&columns);
+			ast_config_destroy(cfg);
+			return AST_MODULE_LOAD_SUCCESS;
+		}
+
+		while ((row = mysql_fetch_row(result))) {
+			struct column *entry;
+			char *cdrvar = "", *staticvalue = "";
+
+			ast_debug(1, "Got a field '%s' of type '%s'\n", row[0], row[1]);
+			/* Check for an alias or a static value */
+			for (var = ast_variable_browse(cfg, "columns"); var; var = var->next) {
+				if (strncmp(var->name, "alias", 5) == 0 && strcasecmp(var->value, row[0]) == 0 ) {
+					char *alias = ast_strdupa(var->name + 5);
+					cdrvar = ast_strip(alias);
+					ast_verb(3, "Found alias %s for column %s\n", cdrvar, row[0]);
+					break;
+				} else if (strncmp(var->name, "static", 6) == 0 && strcasecmp(var->value, row[0]) == 0) {
+					char *item = ast_strdupa(var->name + 6);
+					item = ast_strip(item);
+					if (item[0] == '"' && item[strlen(item) - 1] == '"') {
+						/* Remove surrounding quotes */
+						item[strlen(item) - 1] = '\0';
+						item++;
+					}
+					staticvalue = item;
+				}
+			}
+
+			entry = ast_calloc(sizeof(char), sizeof(*entry) + strlen(row[0]) + 1 + strlen(cdrvar) + 1 + strlen(staticvalue) + 1 + strlen(row[1]) + 1);
+			if (!entry) {
+				ast_log(LOG_ERROR, "Out of memory creating entry for column '%s'\n", row[0]);
+				res = -1;
+				break;
+			}
+
+			entry->name = (char *)entry + sizeof(*entry);
+			strcpy(entry->name, row[0]);
+
+			if (!ast_strlen_zero(cdrvar)) {
+				entry->cdrname = entry->name + strlen(row[0]) + 1;
+				strcpy(entry->cdrname, cdrvar);
+			} else { /* Point to same place as the column name */
+				entry->cdrname = (char *)entry + sizeof(*entry);
+			}
+
+			if (!ast_strlen_zero(staticvalue)) {
+				entry->staticvalue = entry->cdrname + strlen(entry->cdrname) + 1;
+				strcpy(entry->staticvalue, staticvalue);
+				ast_debug(1, "staticvalue length: %d\n", (int) strlen(staticvalue) );
+				entry->type = entry->staticvalue + strlen(entry->staticvalue) + 1;
+			} else {
+				entry->type = entry->cdrname + strlen(entry->cdrname) + 1;
+			}
+			strcpy(entry->type, row[1]);
+
+			ast_debug(1, "Entry name '%s'\n", entry->name);
+			ast_debug(1, "   cdrname '%s'\n", entry->cdrname);
+			ast_debug(1, "    static '%s'\n", entry->staticvalue);
+			ast_debug(1, "      type '%s'\n", entry->type);
+
+			AST_LIST_INSERT_TAIL(&columns, entry, list);
+		}
+		mysql_free_result(result);
+	}
+	AST_RWLIST_UNLOCK(&columns);
+	ast_config_destroy(cfg);
+	if (res < 0) {
+		return AST_MODULE_LOAD_FAILURE;
+	}
+
+	res = ast_cdr_register(name, desc, mysql_log);
+	if (res) {
+		ast_log(LOG_ERROR, "Unable to register MySQL CDR handling\n");
+	} else {
+		res = ast_cli_register_multiple(cdr_mysql_status_cli, sizeof(cdr_mysql_status_cli) / sizeof(struct ast_cli_entry));
+	}
+
+	return res;
+}
+
+static int load_module(void)
+{
+	return my_load_module(0);
+}
+
+static int unload_module(void)
+{
+	return my_unload_module(0);
+}
+
+static int reload(void)
+{
+	int ret;
+
+	ast_mutex_lock(&mysql_lock);
+	ret = my_load_module(1);
+	ast_mutex_unlock(&mysql_lock);
+
+	return ret;
+}
+
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "MySQL CDR Backend",
+	.load = load_module,
+	.unload = unload_module,
+	.reload = reload,
+);
+
diff --git a/addons/chan_mobile.c b/addons/chan_mobile.c
new file mode 100644
index 000000000..415ca617e
--- /dev/null
+++ b/addons/chan_mobile.c
@@ -0,0 +1,4266 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2006, Digium, Inc.
+ *
+ * Mark Spencer <markster@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! 
+ * \file
+ * \brief Bluetooth Mobile Device channel driver
+ *
+ * \author Dave Bowerman <david.bowerman@gmail.com>
+ *
+ * \ingroup channel_drivers
+ */
+
+/*** MODULEINFO
+	<depend>bluetooth</depend>
+	<defaultenabled>no</defaultenabled>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <pthread.h>
+#include <signal.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+#include <bluetooth/sdp.h>
+#include <bluetooth/sdp_lib.h>
+#include <bluetooth/rfcomm.h>
+#include <bluetooth/sco.h>
+#include <bluetooth/l2cap.h>
+
+#include "asterisk/compat.h"
+#include "asterisk/lock.h"
+#include "asterisk/channel.h"
+#include "asterisk/config.h"
+#include "asterisk/logger.h"
+#include "asterisk/module.h"
+#include "asterisk/pbx.h"
+#include "asterisk/options.h"
+#include "asterisk/utils.h"
+#include "asterisk/linkedlists.h"
+#include "asterisk/cli.h"
+#include "asterisk/devicestate.h"
+#include "asterisk/causes.h"
+#include "asterisk/dsp.h"
+#include "asterisk/app.h"
+#include "asterisk/manager.h"
+#include "asterisk/io.h"
+
+#define MBL_CONFIG "mobile.conf"
+
+#define DEVICE_FRAME_SIZE 48
+#define DEVICE_FRAME_FORMAT AST_FORMAT_SLINEAR
+#define CHANNEL_FRAME_SIZE 320
+
+static int prefformat = DEVICE_FRAME_FORMAT;
+
+static int discovery_interval = 60;			/* The device discovery interval, default 60 seconds. */
+static pthread_t discovery_thread = AST_PTHREADT_NULL;	/* The discovery thread */
+static sdp_session_t *sdp_session;
+
+AST_MUTEX_DEFINE_STATIC(unload_mutex);
+static int unloading_flag = 0;
+static inline int check_unloading(void);
+static inline void set_unloading(void);
+
+enum mbl_type {
+	MBL_TYPE_PHONE,
+	MBL_TYPE_HEADSET
+};
+
+struct adapter_pvt {
+	int dev_id;					/* device id */
+	int hci_socket;					/* device descriptor */
+	char id[31];					/* the 'name' from mobile.conf */
+	bdaddr_t addr;					/* adddress of adapter */
+	unsigned int inuse:1;				/* are we in use ? */
+	unsigned int alignment_detection:1;		/* do alignment detection on this adpater? */
+	struct io_context *io;				/*!< io context for audio connections */
+	struct io_context *accept_io;			/*!< io context for sco listener */
+	int *sco_id;					/*!< the io context id of the sco listener socket */
+	int sco_socket;					/*!< sco listener socket */
+	pthread_t sco_listener_thread;			/*!< sco listener thread */
+	AST_LIST_ENTRY(adapter_pvt) entry;
+};
+
+static AST_RWLIST_HEAD_STATIC(adapters, adapter_pvt);
+
+struct msg_queue_entry;
+struct hfp_pvt;
+struct mbl_pvt {
+	struct ast_channel *owner;			/* Channel we belong to, possibly NULL */
+	struct ast_frame fr;				/* "null" frame */
+	ast_mutex_t lock;				/*!< pvt lock */
+	/*! queue for messages we are expecting */
+	AST_LIST_HEAD_NOLOCK(msg_queue, msg_queue_entry) msg_queue;
+	enum mbl_type type;				/* Phone or Headset */
+	char id[31];					/* The id from mobile.conf */
+	int group;					/* group number for group dialling */
+	bdaddr_t addr;					/* address of device */
+	struct adapter_pvt *adapter;			/* the adapter we use */
+	char context[AST_MAX_CONTEXT];			/* the context for incoming calls */
+	struct hfp_pvt *hfp;				/*!< hfp pvt */
+	int rfcomm_port;				/* rfcomm port number */
+	int rfcomm_socket;				/* rfcomm socket descriptor */
+	char rfcomm_buf[256];
+	char io_buf[CHANNEL_FRAME_SIZE + AST_FRIENDLY_OFFSET];
+	struct ast_smoother *smoother;			/* our smoother, for making 48 byte frames */
+	int sco_socket;					/* sco socket descriptor */
+	pthread_t monitor_thread;			/* monitor thread handle */
+	int timeout;					/*!< used to set the timeout for rfcomm data (may be used in the future) */
+	unsigned int no_callsetup:1;
+	unsigned int has_sms:1;
+	unsigned int do_alignment_detection:1;
+	unsigned int alignment_detection_triggered:1;
+	unsigned int blackberry:1;
+	short alignment_samples[4];
+	int alignment_count;
+	int ring_sched_id;
+	struct ast_dsp *dsp;
+	struct sched_context *sched;
+
+	/* flags */
+	unsigned int outgoing:1;	/*!< outgoing call */
+	unsigned int incoming:1;	/*!< incoming call */
+	unsigned int outgoing_sms:1;	/*!< outgoing sms */
+	unsigned int incoming_sms:1;	/*!< outgoing sms */
+	unsigned int needcallerid:1;	/*!< we need callerid */
+	unsigned int needchup:1;	/*!< we need to send a chup */
+	unsigned int needring:1;	/*!< we need to send a RING */
+	unsigned int answered:1;	/*!< we sent/recieved an answer */
+	unsigned int connected:1;	/*!< do we have an rfcomm connection to a device */
+
+	AST_LIST_ENTRY(mbl_pvt) entry;
+};
+
+static AST_RWLIST_HEAD_STATIC(devices, mbl_pvt);
+
+static int handle_response_ok(struct mbl_pvt *pvt, char *buf);
+static int handle_response_error(struct mbl_pvt *pvt, char *buf);
+static int handle_response_ciev(struct mbl_pvt *pvt, char *buf);
+static int handle_response_clip(struct mbl_pvt *pvt, char *buf);
+static int handle_response_ring(struct mbl_pvt *pvt, char *buf);
+static int handle_response_cmti(struct mbl_pvt *pvt, char *buf);
+static int handle_response_cmgr(struct mbl_pvt *pvt, char *buf);
+static int handle_sms_prompt(struct mbl_pvt *pvt, char *buf);
+
+/* CLI stuff */
+static char *handle_cli_mobile_show_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
+static char *handle_cli_mobile_search(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
+static char *handle_cli_mobile_rfcomm(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
+
+static struct ast_cli_entry mbl_cli[] = {
+	AST_CLI_DEFINE(handle_cli_mobile_show_devices, "Show Bluetooth Cell / Mobile devices"),
+	AST_CLI_DEFINE(handle_cli_mobile_search,       "Search for Bluetooth Cell / Mobile devices"),
+	AST_CLI_DEFINE(handle_cli_mobile_rfcomm,       "Send commands to the rfcomm port for debugging"),
+};
+
+/* App stuff */
+static char *app_mblstatus = "MobileStatus";
+static char *mblstatus_synopsis = "MobileStatus(Device,Variable)";
+static char *mblstatus_desc =
+"MobileStatus(Device,Variable)\n"
+"  Device - Id of mobile device from mobile.conf\n"
+"  Variable - Variable to store status in will be 1-3.\n"
+"             In order, Disconnected, Connected & Free, Connected & Busy.\n";
+
+static char *app_mblsendsms = "MobileSendSMS";
+static char *mblsendsms_synopsis = "MobileSendSMS(Device,Dest,Message)";
+static char *mblsendsms_desc =
+"MobileSendSms(Device,Dest,Message)\n"
+"  Device - Id of device from mobile.conf\n"
+"  Dest - destination\n"
+"  Message - text of the message\n";
+
+static struct ast_channel *mbl_new(int state, struct mbl_pvt *pvt, char *cid_num,
+		const struct ast_channel *requestor);
+static struct ast_channel *mbl_request(const char *type, int format,
+		const struct ast_channel *requestor, void *data, int *cause);
+static int mbl_call(struct ast_channel *ast, char *dest, int timeout);
+static int mbl_hangup(struct ast_channel *ast);
+static int mbl_answer(struct ast_channel *ast);
+static int mbl_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
+static struct ast_frame *mbl_read(struct ast_channel *ast);
+static int mbl_write(struct ast_channel *ast, struct ast_frame *frame);
+static int mbl_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
+static int mbl_devicestate(void *data);
+
+static void do_alignment_detection(struct mbl_pvt *pvt, char *buf, int buflen);
+
+static int mbl_queue_control(struct mbl_pvt *pvt, enum ast_control_frame_type control);
+static int mbl_queue_hangup(struct mbl_pvt *pvt);
+static int mbl_ast_hangup(struct mbl_pvt *pvt);
+
+static int rfcomm_connect(bdaddr_t src, bdaddr_t dst, int remote_channel);
+static int rfcomm_write(int rsock, char *buf);
+static int rfcomm_write_full(int rsock, char *buf, size_t count);
+static int rfcomm_wait(int rsock, int *ms);
+static ssize_t rfcomm_read(int rsock, char *buf, size_t count);
+
+static int sco_connect(bdaddr_t src, bdaddr_t dst);
+static int sco_write(int s, char *buf, int len);
+static int sco_accept(int *id, int fd, short events, void *data);
+static int sco_bind(struct adapter_pvt *adapter);
+
+static void *do_sco_listen(void *data);
+static int sdp_search(char *addr, int profile);
+
+static int headset_send_ring(const void *data);
+
+/*
+ * bluetooth handsfree profile helpers
+ */
+
+#define HFP_HF_ECNR	(1 << 0)
+#define HFP_HF_CW	(1 << 1)
+#define HFP_HF_CID	(1 << 2)
+#define HFP_HF_VOICE	(1 << 3)
+#define HFP_HF_VOLUME	(1 << 4)
+#define HFP_HF_STATUS	(1 << 5)
+#define HFP_HF_CONTROL	(1 << 6)
+
+#define HFP_AG_CW	(1 << 0)
+#define HFP_AG_ECNR	(1 << 1)
+#define HFP_AG_VOICE	(1 << 2)
+#define HFP_AG_RING	(1 << 3)
+#define HFP_AG_TAG	(1 << 4)
+#define HFP_AG_REJECT	(1 << 5)
+#define HFP_AG_STATUS	(1 << 6)
+#define HFP_AG_CONTROL	(1 << 7)
+#define HFP_AG_ERRORS	(1 << 8)
+
+#define HFP_CIND_UNKNOWN	-1
+#define HFP_CIND_NONE		0
+#define HFP_CIND_SERVICE	1
+#define HFP_CIND_CALL		2
+#define HFP_CIND_CALLSETUP	3
+#define HFP_CIND_CALLHELD	4
+#define HFP_CIND_SIGNAL		5
+#define HFP_CIND_ROAM		6
+#define HFP_CIND_BATTCHG	7
+
+/* call indicator values */
+#define HFP_CIND_CALL_NONE	0
+#define HFP_CIND_CALL_ACTIVE	1
+
+/* callsetup indicator values */
+#define HFP_CIND_CALLSETUP_NONE		0
+#define HFP_CIND_CALLSETUP_INCOMING	1
+#define HFP_CIND_CALLSETUP_OUTGOING	2
+#define HFP_CIND_CALLSETUP_ALERTING	3
+
+/*!
+ * \brief This struct holds HFP features that we support.
+ */
+struct hfp_hf {
+	int ecnr:1;	/*!< echo-cancel/noise reduction */
+	int cw:1;	/*!< call waiting and three way calling */
+	int cid:1;	/*!< cli presentation (callier id) */
+	int voice:1;	/*!< voice recognition activation */
+	int volume:1;	/*!< remote volume control */
+	int status:1;	/*!< enhanced call status */
+	int control:1;	/*!< enhanced call control*/
+};
+
+/*!
+ * \brief This struct holds HFP features the AG supports.
+ */
+struct hfp_ag {
+	int cw:1;	/*!< three way calling */
+	int ecnr:1;	/*!< echo-cancel/noise reduction */
+	int voice:1;	/*!< voice recognition */
+	int ring:1;	/*!< in band ring tone capability */
+	int tag:1;	/*!< attach a number to a voice tag */
+	int reject:1;	/*!< ability to reject a call */
+	int status:1;	/*!< enhanced call status */
+	int control:1;	/*!< enhanced call control*/
+	int errors:1;	/*!< extended error result codes*/
+};
+
+/*!
+ * \brief This struct holds mappings for indications.
+ */
+struct hfp_cind {
+	int service;	/*!< whether we have service or not */
+	int call;	/*!< call state */
+	int callsetup;	/*!< bluetooth call setup indications */
+	int callheld;	/*!< bluetooth call hold indications */
+	int signal;	/*!< signal strength */
+	int roam;	/*!< roaming indicator */
+	int battchg;	/*!< battery charge indicator */
+};
+
+
+/*!
+ * \brief This struct holds state information about the current hfp connection.
+ */
+struct hfp_pvt {
+	struct mbl_pvt *owner;		/*!< the mbl_pvt struct that owns this struct */
+	int initialized:1;		/*!< whether a service level connection exists or not */
+	int nocallsetup:1;		/*!< whether we detected a callsetup indicator */
+	struct hfp_ag brsf;		/*!< the supported feature set of the AG */
+	int cind_index[16];		/*!< the cind/ciev index to name mapping for this AG */
+	int cind_state[16];		/*!< the cind/ciev state for this AG */
+	struct hfp_cind cind_map;	/*!< the cind name to index mapping for this AG */
+	int rsock;			/*!< our rfcomm socket */
+	int rport;			/*!< our rfcomm port */
+};
+
+
+/* Our supported features.
+ * we only support caller id
+ */
+static struct hfp_hf hfp_our_brsf = {
+	.ecnr = 0,
+	.cw = 0,
+	.cid = 1,
+	.voice = 0,
+	.volume = 0,
+	.status = 0,
+	.control = 0,
+};
+
+
+static int hfp_parse_ciev(struct hfp_pvt *hfp, char *buf, int *value);
+static char *hfp_parse_clip(struct hfp_pvt *hfp, char *buf);
+static int hfp_parse_cmti(struct hfp_pvt *hfp, char *buf);
+static int hfp_parse_cmgr(struct hfp_pvt *hfp, char *buf, char **from_number, char **text);
+static int hfp_parse_brsf(struct hfp_pvt *hfp, const char *buf);
+static int hfp_parse_cind(struct hfp_pvt *hfp, char *buf);
+static int hfp_parse_cind_test(struct hfp_pvt *hfp, char *buf);
+
+static int hfp_brsf2int(struct hfp_hf *hf);
+static struct hfp_ag *hfp_int2brsf(int brsf, struct hfp_ag *ag);
+
+static int hfp_send_brsf(struct hfp_pvt *hfp, struct hfp_hf *brsf);
+static int hfp_send_cind(struct hfp_pvt *hfp);
+static int hfp_send_cind_test(struct hfp_pvt *hfp);
+static int hfp_send_cmer(struct hfp_pvt *hfp, int status);
+static int hfp_send_clip(struct hfp_pvt *hfp, int status);
+static int hfp_send_vgs(struct hfp_pvt *hfp, int value);
+
+#if 0
+static int hfp_send_vgm(struct hfp_pvt *hfp, int value);
+#endif
+static int hfp_send_dtmf(struct hfp_pvt *hfp, char digit);
+static int hfp_send_cmgf(struct hfp_pvt *hfp, int mode);
+static int hfp_send_cnmi(struct hfp_pvt *hfp);
+static int hfp_send_cmgr(struct hfp_pvt *hfp, int index);
+static int hfp_send_cmgs(struct hfp_pvt *hfp, const char *number);
+static int hfp_send_sms_text(struct hfp_pvt *hfp, const char *message);
+static int hfp_send_chup(struct hfp_pvt *hfp);
+static int hfp_send_atd(struct hfp_pvt *hfp, const char *number);
+static int hfp_send_ata(struct hfp_pvt *hfp);
+
+/*
+ * bluetooth headset profile helpers
+ */
+static int hsp_send_ok(int rsock);
+static int hsp_send_error(int rsock);
+static int hsp_send_vgs(int rsock, int gain);
+static int hsp_send_vgm(int rsock, int gain);
+static int hsp_send_ring(int rsock);
+
+
+/*
+ * Hayes AT command helpers
+ */
+typedef enum {
+	/* errors */
+	AT_PARSE_ERROR = -2,
+	AT_READ_ERROR = -1,
+	AT_UNKNOWN = 0,
+	/* at responses */
+	AT_OK,
+	AT_ERROR,
+	AT_RING,
+	AT_BRSF,
+	AT_CIND,
+	AT_CIEV,
+	AT_CLIP,
+	AT_CMTI,
+	AT_CMGR,
+	AT_SMS_PROMPT,
+	AT_CMS_ERROR,
+	/* at commands */
+	AT_A,
+	AT_D,
+	AT_CHUP,
+	AT_CKPD,
+	AT_CMGS,
+	AT_VGM,
+	AT_VGS,
+	AT_VTS,
+	AT_CMGF,
+	AT_CNMI,
+	AT_CMER,
+	AT_CIND_TEST,
+} at_message_t;
+
+static int at_match_prefix(char *buf, char *prefix);
+static at_message_t at_read_full(int rsock, char *buf, size_t count);
+static inline const char *at_msg2str(at_message_t msg);
+
+struct msg_queue_entry {
+	at_message_t expected;
+	at_message_t response_to;
+	void *data;
+
+	AST_LIST_ENTRY(msg_queue_entry) entry;
+};
+
+static int msg_queue_push(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to);
+static int msg_queue_push_data(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to, void *data);
+static struct msg_queue_entry *msg_queue_pop(struct mbl_pvt *pvt);
+static void msg_queue_free_and_pop(struct mbl_pvt *pvt);
+static void msg_queue_flush(struct mbl_pvt *pvt);
+static struct msg_queue_entry *msg_queue_head(struct mbl_pvt *pvt);
+
+/*
+ * channel stuff
+ */
+
+static const struct ast_channel_tech mbl_tech = {
+	.type = "Mobile",
+	.description = "Bluetooth Mobile Device Channel Driver",
+	.capabilities = AST_FORMAT_SLINEAR,
+	.requester = mbl_request,
+	.call = mbl_call,
+	.hangup = mbl_hangup,
+	.answer = mbl_answer,
+	.send_digit_end = mbl_digit_end,
+	.read = mbl_read,
+	.write = mbl_write,
+	.fixup = mbl_fixup,
+	.devicestate = mbl_devicestate
+};
+
+/* CLI Commands implementation */
+
+static char *handle_cli_mobile_show_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	struct mbl_pvt *pvt;
+	char bdaddr[18];
+	char group[6];
+
+#define FORMAT1 "%-15.15s %-17.17s %-5.5s %-15.15s %-9.9s %-5.5s %-3.3s\n"
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "mobile show devices";
+		e->usage =
+			"Usage: mobile show devices\n"
+			"       Shows the state of Bluetooth Cell / Mobile devices.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 3)
+		return CLI_SHOWUSAGE;
+
+	ast_cli(a->fd, FORMAT1, "ID", "Address", "Group", "Adapter", "Connected", "State", "SMS");
+	AST_RWLIST_RDLOCK(&devices);
+	AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
+		ast_mutex_lock(&pvt->lock);
+		ba2str(&pvt->addr, bdaddr);
+		snprintf(group, sizeof(group), "%d", pvt->group);
+		ast_cli(a->fd, FORMAT1,
+				pvt->id,
+				bdaddr,
+				group,
+				pvt->adapter->id,
+				pvt->connected ? "Yes" : "No",
+				(!pvt->connected) ? "None" : (pvt->owner) ? "Busy" : (pvt->outgoing_sms || pvt->incoming_sms) ? "SMS" : "Free",
+				(pvt->has_sms) ? "Yes" : "No"
+		       );
+		ast_mutex_unlock(&pvt->lock);
+	}
+	AST_RWLIST_UNLOCK(&devices);
+
+#undef FORMAT1
+
+	return CLI_SUCCESS;
+}
+
+static char *handle_cli_mobile_search(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	struct adapter_pvt *adapter;
+	inquiry_info *ii = NULL;
+	int max_rsp, num_rsp;
+	int len, flags;
+	int i, phport, hsport;
+	char addr[19] = {0};
+	char name[31] = {0};
+
+#define FORMAT1 "%-17.17s %-30.30s %-6.6s %-7.7s %-4.4s\n"
+#define FORMAT2 "%-17.17s %-30.30s %-6.6s %-7.7s %d\n"
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "mobile search";
+		e->usage =
+			"Usage: mobile search\n"
+			"       Searches for Bluetooth Cell / Mobile devices in range.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 2)
+		return CLI_SHOWUSAGE;
+
+	/* find a free adapter */
+	AST_RWLIST_RDLOCK(&adapters);
+	AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
+		if (!adapter->inuse)
+			break;
+	}
+	AST_RWLIST_UNLOCK(&adapters);
+
+	if (!adapter) {
+		ast_cli(a->fd, "All Bluetooth adapters are in use at this time.\n");
+		return CLI_SUCCESS;
+	}
+
+	len  = 8;
+	max_rsp = 255;
+	flags = IREQ_CACHE_FLUSH;
+
+	ii = alloca(max_rsp * sizeof(inquiry_info));
+	num_rsp = hci_inquiry(adapter->dev_id, len, max_rsp, NULL, &ii, flags);
+	if (num_rsp > 0) {
+		ast_cli(a->fd, FORMAT1, "Address", "Name", "Usable", "Type", "Port");
+		for (i = 0; i < num_rsp; i++) {
+			ba2str(&(ii + i)->bdaddr, addr);
+			name[0] = 0x00;
+			if (hci_read_remote_name(adapter->hci_socket, &(ii + i)->bdaddr, sizeof(name) - 1, name, 0) < 0)
+				strcpy(name, "[unknown]");
+			phport = sdp_search(addr, HANDSFREE_AGW_PROFILE_ID);
+			if (!phport)
+				hsport = sdp_search(addr, HEADSET_PROFILE_ID);
+			else
+				hsport = 0;
+			ast_cli(a->fd, FORMAT2, addr, name, (phport > 0 || hsport > 0) ? "Yes" : "No",
+				(phport > 0) ? "Phone" : "Headset", (phport > 0) ? phport : hsport);
+		}
+	} else
+		ast_cli(a->fd, "No Bluetooth Cell / Mobile devices found.\n");
+
+#undef FORMAT1
+#undef FORMAT2
+
+	return CLI_SUCCESS;
+}
+
+static char *handle_cli_mobile_rfcomm(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	char buf[128];
+	struct mbl_pvt *pvt = NULL;
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "mobile rfcomm";
+		e->usage =
+			"Usage: mobile rfcomm <device ID> <command>\n"
+			"       Send <command> to the rfcomm port on the device\n"
+			"       with the specified <device ID>.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 4)
+		return CLI_SHOWUSAGE;
+
+	AST_RWLIST_RDLOCK(&devices);
+	AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
+		if (!strcmp(pvt->id, a->argv[2]))
+			break;
+	}
+	AST_RWLIST_UNLOCK(&devices);
+
+	if (!pvt) {
+		ast_cli(a->fd, "Device %s not found.\n", a->argv[2]);
+		goto e_return;
+	}
+
+	ast_mutex_lock(&pvt->lock);
+	if (!pvt->connected) {
+		ast_cli(a->fd, "Device %s not connected.\n", a->argv[2]);
+		goto e_unlock_pvt;
+	}
+
+	snprintf(buf, sizeof(buf), "%s\r", a->argv[3]);
+	rfcomm_write(pvt->rfcomm_socket, buf);
+	msg_queue_push(pvt, AT_OK, AT_UNKNOWN);
+
+e_unlock_pvt:
+	ast_mutex_unlock(&pvt->lock);
+e_return:
+	return CLI_SUCCESS;
+}
+
+/*
+
+	Dialplan applications implementation
+
+*/
+
+static int mbl_status_exec(struct ast_channel *ast, const char *data)
+{
+
+	struct mbl_pvt *pvt;
+	char *parse;
+	int stat;
+	char status[2];
+
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(device);
+		AST_APP_ARG(variable);
+	);
+
+	if (ast_strlen_zero(data))
+		return -1;
+
+	parse = ast_strdupa(data);
+
+	AST_STANDARD_APP_ARGS(args, parse);
+
+	if (ast_strlen_zero(args.device) || ast_strlen_zero(args.variable))
+		return -1;
+
+	stat = 1;
+
+	AST_RWLIST_RDLOCK(&devices);
+	AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
+		if (!strcmp(pvt->id, args.device))
+			break;
+	}
+	AST_RWLIST_UNLOCK(&devices);
+
+	if (pvt) {
+		ast_mutex_lock(&pvt->lock);
+		if (pvt->connected)
+			stat = 2;
+		if (pvt->owner)
+			stat = 3;
+		ast_mutex_unlock(&pvt->lock);
+	}
+
+	snprintf(status, sizeof(status), "%d", stat);
+	pbx_builtin_setvar_helper(ast, args.variable, status);
+
+	return 0;
+
+}
+
+static int mbl_sendsms_exec(struct ast_channel *ast, const char *data)
+{
+
+	struct mbl_pvt *pvt;
+	char *parse, *message;
+
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(device);
+		AST_APP_ARG(dest);
+		AST_APP_ARG(message);
+	);
+
+	if (ast_strlen_zero(data))
+		return -1;
+
+	parse = ast_strdupa(data);
+
+	AST_STANDARD_APP_ARGS(args, parse);
+
+	if (ast_strlen_zero(args.device)) {
+		ast_log(LOG_ERROR,"NULL device for message -- SMS will not be sent.\n");
+		return -1;
+	}
+
+	if (ast_strlen_zero(args.dest)) {
+		ast_log(LOG_ERROR,"NULL destination for message -- SMS will not be sent.\n");
+		return -1;
+	}
+
+	if (ast_strlen_zero(args.message)) {
+		ast_log(LOG_ERROR,"NULL Message to be sent -- SMS will not be sent.\n");
+		return -1;
+	}
+
+	AST_RWLIST_RDLOCK(&devices);
+	AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
+		if (!strcmp(pvt->id, args.device))
+			break;
+	}
+	AST_RWLIST_UNLOCK(&devices);
+
+	if (!pvt) {
+		ast_log(LOG_ERROR,"Bluetooth device %s wasn't found in the list -- SMS will not be sent.\n", args.device);
+		goto e_return;
+	}
+
+	ast_mutex_lock(&pvt->lock);
+	if (!pvt->connected) {
+		ast_log(LOG_ERROR,"Bluetooth device %s wasn't connected -- SMS will not be sent.\n", args.device);
+		goto e_unlock_pvt;
+	}
+
+	if (!pvt->has_sms) {
+		ast_log(LOG_ERROR,"Bluetooth device %s doesn't handle SMS -- SMS will not be sent.\n", args.device);
+		goto e_unlock_pvt;
+	}
+
+	message = ast_strdup(args.message);
+
+	if (hfp_send_cmgs(pvt->hfp, args.dest)
+		|| msg_queue_push_data(pvt, AT_SMS_PROMPT, AT_CMGS, message)) {
+
+		ast_log(LOG_ERROR, "[%s] problem sending SMS message\n", pvt->id);
+		goto e_free_message;
+	}
+
+	ast_mutex_unlock(&pvt->lock);
+
+	return 0;
+
+e_free_message:
+	ast_free(message);
+e_unlock_pvt:
+	ast_mutex_unlock(&pvt->lock);
+e_return:
+	return -1;
+}
+
+/*
+
+	Channel Driver callbacks
+
+*/
+
+static struct ast_channel *mbl_new(int state, struct mbl_pvt *pvt, char *cid_num,
+		const struct ast_channel *requestor)
+{
+
+	struct ast_channel *chn;
+
+	pvt->answered = 0;
+	pvt->alignment_count = 0;
+	pvt->alignment_detection_triggered = 0;
+	if (pvt->adapter->alignment_detection)
+		pvt->do_alignment_detection = 1;
+	else
+		pvt->do_alignment_detection = 0;
+
+	ast_smoother_reset(pvt->smoother, DEVICE_FRAME_SIZE);
+	ast_dsp_digitreset(pvt->dsp);
+
+	chn = ast_channel_alloc(1, state, cid_num, pvt->id, 0, 0, pvt->context,
+			requestor ? requestor->linkedid : "", 0,
+			"Mobile/%s-%04lx", pvt->id, ast_random() & 0xffff);
+	if (!chn) {
+		goto e_return;
+	}
+
+	chn->tech = &mbl_tech;
+	chn->nativeformats = prefformat;
+	chn->rawreadformat = prefformat;
+	chn->rawwriteformat = prefformat;
+	chn->writeformat = prefformat;
+	chn->readformat = prefformat;
+	chn->tech_pvt = pvt;
+
+	if (state == AST_STATE_RING)
+		chn->rings = 1;
+
+	ast_string_field_set(chn, language, "en");
+	pvt->owner = chn;
+
+	if (pvt->sco_socket != -1) {
+		ast_channel_set_fd(chn, 0, pvt->sco_socket);
+	}
+
+	return chn;
+
+e_return:
+	return NULL;
+}
+
+static struct ast_channel *mbl_request(const char *type, int format,
+		const struct ast_channel *requestor, void *data, int *cause)
+{
+
+	struct ast_channel *chn = NULL;
+	struct mbl_pvt *pvt;
+	char *dest_dev = NULL;
+	char *dest_num = NULL;
+	int oldformat, group = -1;
+
+	if (!data) {
+		ast_log(LOG_WARNING, "Channel requested with no data\n");
+		*cause = AST_CAUSE_INCOMPATIBLE_DESTINATION;
+		return NULL;
+	}
+
+	oldformat = format;
+	format &= (AST_FORMAT_SLINEAR);
+	if (!format) {
+		ast_log(LOG_WARNING, "Asked to get a channel of unsupported format '%d'\n", oldformat);
+		*cause = AST_CAUSE_FACILITY_NOT_IMPLEMENTED;
+		return NULL;
+	}
+
+	dest_dev = ast_strdupa((char *)data);
+
+	dest_num = strchr(dest_dev, '/');
+	if (dest_num)
+		*dest_num++ = 0x00;
+
+	if (((dest_dev[0] == 'g') || (dest_dev[0] == 'G')) && ((dest_dev[1] >= '0') && (dest_dev[1] <= '9'))) {
+		group = atoi(&dest_dev[1]);
+	}
+
+	/* Find requested device and make sure it's connected. */
+	AST_RWLIST_RDLOCK(&devices);
+	AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
+		if (group > -1 && pvt->group == group && pvt->connected && !pvt->owner) {
+			break;
+		} else if (!strcmp(pvt->id, dest_dev)) {
+			break;
+		}
+	}
+	AST_RWLIST_UNLOCK(&devices);
+	if (!pvt || !pvt->connected || pvt->owner) {
+		ast_log(LOG_WARNING, "Request to call on device %s which is not connected / already in use.\n", dest_dev);
+		*cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
+		return NULL;
+	}
+
+	if ((pvt->type == MBL_TYPE_PHONE) && !dest_num) {
+		ast_log(LOG_WARNING, "Can't determine destination number.\n");
+		*cause = AST_CAUSE_INCOMPATIBLE_DESTINATION;
+		return NULL;
+	}
+
+	ast_mutex_lock(&pvt->lock);
+	chn = mbl_new(AST_STATE_DOWN, pvt, NULL, requestor);
+	ast_mutex_unlock(&pvt->lock);
+	if (!chn) {
+		ast_log(LOG_WARNING, "Unable to allocate channel structure.\n");
+		*cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
+		return NULL;
+	}
+
+	return chn;
+
+}
+
+static int mbl_call(struct ast_channel *ast, char *dest, int timeout)
+{
+
+	struct mbl_pvt *pvt;
+	char *dest_dev = NULL;
+	char *dest_num = NULL;
+
+	dest_dev = ast_strdupa((char *)dest);
+
+	pvt = ast->tech_pvt;
+
+	if (pvt->type == MBL_TYPE_PHONE) {
+		dest_num = strchr(dest_dev, '/');
+		if (!dest_num) {
+			ast_log(LOG_WARNING, "Cant determine destination number.\n");
+			return -1;
+		}
+		*dest_num++ = 0x00;
+	}
+
+	if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
+		ast_log(LOG_WARNING, "mbl_call called on %s, neither down nor reserved\n", ast->name);
+		return -1;
+	}
+
+	ast_debug(1, "Calling %s on %s\n", dest, ast->name);
+
+	ast_mutex_lock(&pvt->lock);
+	if (pvt->type == MBL_TYPE_PHONE) {
+		if (hfp_send_atd(pvt->hfp, dest_num)) {
+			ast_mutex_unlock(&pvt->lock);
+			ast_log(LOG_ERROR, "error sending ATD command on %s\n", pvt->id);
+			return -1;
+		}
+		pvt->needchup = 1;
+		msg_queue_push(pvt, AT_OK, AT_D);
+	} else {
+		if (hsp_send_ring(pvt->rfcomm_socket)) {
+			ast_log(LOG_ERROR, "[%s] error ringing device\n", pvt->id);
+			ast_mutex_unlock(&pvt->lock);
+			return -1;
+		}
+
+		if ((pvt->ring_sched_id = ast_sched_add(pvt->sched, 6000, headset_send_ring, pvt)) == -1) {
+			ast_log(LOG_ERROR, "[%s] error ringing device\n", pvt->id);
+			ast_mutex_unlock(&pvt->lock);
+			return -1;
+		}
+
+		pvt->outgoing = 1;
+		pvt->needring = 1;
+	}
+	ast_mutex_unlock(&pvt->lock);
+
+	return 0;
+
+}
+
+static int mbl_hangup(struct ast_channel *ast)
+{
+
+	struct mbl_pvt *pvt;
+
+	if (!ast->tech_pvt) {
+		ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
+		return 0;
+	}
+	pvt = ast->tech_pvt;
+
+	ast_debug(1, "[%s] hanging up device\n", pvt->id);
+
+	ast_mutex_lock(&pvt->lock);
+	ast_channel_set_fd(ast, 0, -1);
+	close(pvt->sco_socket);
+	pvt->sco_socket = -1;
+
+	if (pvt->needchup) {
+		hfp_send_chup(pvt->hfp);
+		msg_queue_push(pvt, AT_OK, AT_CHUP);
+		pvt->needchup = 0;
+	}
+
+	pvt->outgoing = 0;
+	pvt->incoming = 0;
+	pvt->needring = 0;
+	pvt->owner = NULL;
+	ast->tech_pvt = NULL;
+
+	ast_mutex_unlock(&pvt->lock);
+
+	ast_setstate(ast, AST_STATE_DOWN);
+
+	return 0;
+
+}
+
+static int mbl_answer(struct ast_channel *ast)
+{
+
+	struct mbl_pvt *pvt;
+
+	pvt = ast->tech_pvt;
+
+	if (pvt->type == MBL_TYPE_HEADSET)
+		return 0;
+
+	ast_mutex_lock(&pvt->lock);
+	if (pvt->incoming) {
+		hfp_send_ata(pvt->hfp);
+		msg_queue_push(pvt, AT_OK, AT_A);
+		pvt->answered = 1;
+	}
+	ast_mutex_unlock(&pvt->lock);
+
+	return 0;
+
+}
+
+static int mbl_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
+{
+	struct mbl_pvt *pvt = ast->tech_pvt;
+
+	if (pvt->type == MBL_TYPE_HEADSET)
+		return 0;
+
+	ast_mutex_lock(&pvt->lock);
+	if (hfp_send_dtmf(pvt->hfp, digit)) {
+		ast_mutex_unlock(&pvt->lock);
+		ast_debug(1, "[%s] error sending digit %c\n", pvt->id, digit);
+		return -1;
+	}
+	msg_queue_push(pvt, AT_OK, AT_VTS);
+	ast_mutex_unlock(&pvt->lock);
+
+	ast_debug(1, "[%s] dialed %c\n", pvt->id, digit);
+
+	return 0;
+}
+
+static struct ast_frame *mbl_read(struct ast_channel *ast)
+{
+
+	struct mbl_pvt *pvt = ast->tech_pvt;
+	struct ast_frame *fr = &ast_null_frame;
+	int r;
+
+	ast_debug(3, "*** mbl_read()\n");
+
+	while (ast_mutex_trylock(&pvt->lock)) {
+		CHANNEL_DEADLOCK_AVOIDANCE(ast);
+	}
+
+	if (!pvt->owner || pvt->sco_socket == -1) {
+		goto e_return;
+	}
+
+	memset(&pvt->fr, 0x00, sizeof(struct ast_frame));
+	pvt->fr.frametype = AST_FRAME_VOICE;
+	pvt->fr.subclass = DEVICE_FRAME_FORMAT;
+	pvt->fr.src = "Mobile";
+	pvt->fr.offset = AST_FRIENDLY_OFFSET;
+	pvt->fr.mallocd = 0;
+	pvt->fr.delivery.tv_sec = 0;
+	pvt->fr.delivery.tv_usec = 0;
+	pvt->fr.data.ptr = pvt->io_buf + AST_FRIENDLY_OFFSET;
+
+	if ((r = read(pvt->sco_socket, pvt->fr.data.ptr, DEVICE_FRAME_SIZE)) == -1) {
+		if (errno != EAGAIN && errno != EINTR) {
+			ast_debug(1, "[%s] read error %d, going to wait for new connection\n", pvt->id, errno);
+			close(pvt->sco_socket);
+			pvt->sco_socket = -1;
+			ast_channel_set_fd(ast, 0, -1);
+		}
+		goto e_return;
+	}
+
+	pvt->fr.datalen = r;
+	pvt->fr.samples = r / 2;
+
+	if (pvt->do_alignment_detection)
+		do_alignment_detection(pvt, pvt->fr.data.ptr, r);
+
+	fr = ast_dsp_process(ast, pvt->dsp, &pvt->fr);
+
+	ast_mutex_unlock(&pvt->lock);
+
+	return fr;
+
+e_return:
+	ast_mutex_unlock(&pvt->lock);
+	return fr;
+}
+
+static int mbl_write(struct ast_channel *ast, struct ast_frame *frame)
+{
+
+	struct mbl_pvt *pvt = ast->tech_pvt;
+	struct ast_frame *f;
+
+	ast_debug(3, "*** mbl_write\n");
+
+	if (frame->frametype != AST_FRAME_VOICE) {
+		return 0;
+	}
+
+	while (ast_mutex_trylock(&pvt->lock)) {
+		CHANNEL_DEADLOCK_AVOIDANCE(ast);
+	}
+
+	ast_smoother_feed(pvt->smoother, frame);
+
+	while ((f = ast_smoother_read(pvt->smoother))) {
+		sco_write(pvt->sco_socket, f->data.ptr, f->datalen);
+		ast_frfree(f);
+	}
+
+	ast_mutex_unlock(&pvt->lock);
+
+	return 0;
+
+}
+
+static int mbl_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
+{
+
+	struct mbl_pvt *pvt = oldchan->tech_pvt;
+
+	if (!pvt) {
+		ast_debug(1, "fixup failed, no pvt on oldchan\n");
+		return -1;
+	}
+
+	ast_mutex_lock(&pvt->lock);
+	if (pvt->owner == oldchan)
+		pvt->owner = newchan;
+	ast_mutex_unlock(&pvt->lock);
+
+	return 0;
+
+}
+
+static int mbl_devicestate(void *data)
+{
+
+	char *device;
+	int res = AST_DEVICE_INVALID;
+	struct mbl_pvt *pvt;
+
+	device = ast_strdupa(S_OR(data, ""));
+
+	ast_debug(1, "Checking device state for device %s\n", device);
+
+	AST_RWLIST_RDLOCK(&devices);
+	AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
+		if (!strcmp(pvt->id, device))
+			break;
+	}
+	AST_RWLIST_UNLOCK(&devices);
+
+	if (!pvt)
+		return res;
+
+	ast_mutex_lock(&pvt->lock);
+	if (pvt->connected) {
+		if (pvt->owner)
+			res = AST_DEVICE_INUSE;
+		else
+			res = AST_DEVICE_NOT_INUSE;
+	}
+	ast_mutex_unlock(&pvt->lock);
+
+	return res;
+
+}
+
+/*
+
+	Callback helpers
+
+*/
+
+/*
+
+	do_alignment_detection()
+
+	This routine attempts to detect where we get misaligned sco audio data from the bluetooth adaptor.
+
+	Its enabled by alignmentdetect=yes under the adapter entry in mobile.conf
+
+	Some adapters suffer a problem where occasionally they will byte shift the audio stream one byte to the right.
+	The result is static or white noise on the inbound (from the adapter) leg of the call.
+	This is characterised by a sudden jump in magnitude of the value of the 16 bit samples.
+
+	Here we look at the first 4 48 byte frames. We average the absolute values of each sample in the frame,
+	then average the sum of the averages of frames 1, 2, and 3.
+	Frame zero is usually zero.
+	If the end result > 100, and it usually is if we have the problem, set a flag and compensate by shifting the bytes
+	for each subsequent frame during the call.
+
+	If the result is <= 100 then clear the flag so we dont come back in here...
+
+	This seems to work OK....
+
+*/
+
+static void do_alignment_detection(struct mbl_pvt *pvt, char *buf, int buflen)
+{
+
+	int i;
+	short a, *s;
+	char *p;
+
+	if (pvt->alignment_detection_triggered) {
+		for (i=buflen, p=buf+buflen-1; i>0; i--, p--)
+			*p = *(p-1);
+		*(p+1) = 0;
+		return;
+	}
+
+	if (pvt->alignment_count < 4) {
+		s = (short *)buf;
+		for (i=0, a=0; i<buflen/2; i++) {
+			a += *s++;
+			a /= i+1;
+		}
+		pvt->alignment_samples[pvt->alignment_count++] = a;
+		return;
+	}
+
+	ast_debug(1, "Alignment Detection result is [%-d %-d %-d %-d]\n", pvt->alignment_samples[0], pvt->alignment_samples[1], pvt->alignment_samples[2], pvt->alignment_samples[3]);
+
+	a = abs(pvt->alignment_samples[1]) + abs(pvt->alignment_samples[2]) + abs(pvt->alignment_samples[3]);
+	a /= 3;
+	if (a > 100) {
+		pvt->alignment_detection_triggered = 1;
+		ast_debug(1, "Alignment Detection Triggered.\n");
+	} else
+		pvt->do_alignment_detection = 0;
+
+}
+
+static int mbl_queue_control(struct mbl_pvt *pvt, enum ast_control_frame_type control)
+{
+	for (;;) {
+		if (pvt->owner) {
+			if (ast_channel_trylock(pvt->owner)) {
+				DEADLOCK_AVOIDANCE(&pvt->lock);
+			} else {
+				ast_queue_control(pvt->owner, control);
+				ast_channel_unlock(pvt->owner);
+				break;
+			}
+		} else
+			break;
+	}
+	return 0;
+}
+
+static int mbl_queue_hangup(struct mbl_pvt *pvt)
+{
+	for (;;) {
+		if (pvt->owner) {
+			if (ast_channel_trylock(pvt->owner)) {
+				DEADLOCK_AVOIDANCE(&pvt->lock);
+			} else {
+				ast_queue_hangup(pvt->owner);
+				ast_channel_unlock(pvt->owner);
+				break;
+			}
+		} else
+			break;
+	}
+	return 0;
+}
+
+static int mbl_ast_hangup(struct mbl_pvt *pvt)
+{
+	int res = 0;
+	for (;;) {
+		if (pvt->owner) {
+			if (ast_channel_trylock(pvt->owner)) {
+				DEADLOCK_AVOIDANCE(&pvt->lock);
+			} else {
+				res = ast_hangup(pvt->owner);
+				/* no need to unlock, ast_hangup() frees the
+				 * channel */
+				break;
+			}
+		} else
+			break;
+	}
+	return res;
+}
+
+/*
+
+	rfcomm helpers
+
+*/
+
+static int rfcomm_connect(bdaddr_t src, bdaddr_t dst, int remote_channel)
+{
+
+	struct sockaddr_rc addr;
+	int s;
+
+	if ((s = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) < 0) {
+		ast_debug(1, "socket() failed (%d).\n", errno);
+		return -1;
+	}
+
+	memset(&addr, 0, sizeof(addr));
+	addr.rc_family = AF_BLUETOOTH;
+	bacpy(&addr.rc_bdaddr, &src);
+	addr.rc_channel = (uint8_t) 1;
+	if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		ast_debug(1, "bind() failed (%d).\n", errno);
+		close(s);
+		return -1;
+	}
+
+	memset(&addr, 0, sizeof(addr));
+	addr.rc_family = AF_BLUETOOTH;
+	bacpy(&addr.rc_bdaddr, &dst);
+	addr.rc_channel = remote_channel;
+	if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		ast_debug(1, "connect() failed (%d).\n", errno);
+		close(s);
+		return -1;
+	}
+
+	return s;
+
+}
+
+/*!
+ * \brief Write to an rfcomm socket.
+ * \param rsock the socket to write to
+ * \param buf the null terminated buffer to write
+ *
+ * This function will write characters from buf.  The buffer must be null
+ * terminated.
+ *
+ * \retval -1 error
+ * \retval 0 success
+ */
+static int rfcomm_write(int rsock, char *buf)
+{
+	return rfcomm_write_full(rsock, buf, strlen(buf));
+}
+
+
+/*!
+ * \brief Write to an rfcomm socket.
+ * \param rsock the socket to write to
+ * \param buf the buffer to write
+ * \param count the number of characters from the buffer to write
+ *
+ * This function will write count characters from buf.  It will always write
+ * count chars unless it encounters an error.
+ *
+ * \retval -1 error
+ * \retval 0 success
+ */
+static int rfcomm_write_full(int rsock, char *buf, size_t count)
+{
+	char *p = buf;
+	ssize_t out_count;
+
+	ast_debug(1, "rfcomm_write() (%d) [%.*s]\n", rsock, (int) count, buf);
+	while (count > 0) {
+		if ((out_count = write(rsock, p, count)) == -1) {
+			ast_debug(1, "rfcomm_write() error [%d]\n", errno);
+			return -1;
+		}
+		count -= out_count;
+		p += out_count;
+	}
+
+	return 0;
+}
+
+/*!
+ * \brief Wait for activity on an rfcomm socket.
+ * \param rsock the socket to watch
+ * \param ms a pointer to an int containing a timeout in ms
+ * \return zero on timeout and the socket fd (non-zero) otherwise
+ * \retval 0 timeout
+ */
+static int rfcomm_wait(int rsock, int *ms)
+{
+	int exception, outfd;
+	outfd = ast_waitfor_n_fd(&rsock, 1, ms, &exception);
+	if (outfd < 0)
+		outfd = 0;
+
+	return outfd;
+}
+
+#ifdef RFCOMM_READ_DEBUG
+#define rfcomm_read_debug(c) __rfcomm_read_debug(c)
+static void __rfcomm_read_debug(char c)
+{
+	if (c == '\r')
+		ast_debug(2, "rfcomm_read: \\r\n");
+	else if (c == '\n')
+		ast_debug(2, "rfcomm_read: \\n\n");
+	else
+		ast_debug(2, "rfcomm_read: %c\n", c);
+}
+#else
+#define rfcomm_read_debug(c)
+#endif
+
+/*!
+ * \brief Append the given character to the given buffer and increase the
+ * in_count.
+ */
+static void inline rfcomm_append_buf(char **buf, size_t count, size_t *in_count, char c)
+{
+	if (*in_count < count) {
+		(*in_count)++;
+		*(*buf)++ = c;
+	}
+}
+
+/*!
+ * \brief Read a character from the given stream and check if it matches what
+ * we expected.
+ */
+static int rfcomm_read_and_expect_char(int rsock, char *result, char expected)
+{
+	int res;
+	char c;
+
+	if (!result)
+		result = &c;
+
+	if ((res = read(rsock, result, 1)) < 1) {
+		return res;
+	}
+	rfcomm_read_debug(*result);
+
+	if (*result != expected) {
+		return -2;
+	}
+
+	return 1;
+}
+
+/*!
+ * \brief Read a character from the given stream and append it to the given
+ * buffer if it matches the expected character.
+ */
+static int rfcomm_read_and_append_char(int rsock, char **buf, size_t count, size_t *in_count, char *result, char expected)
+{
+	int res;
+	char c;
+
+	if (!result)
+		result = &c;
+
+	if ((res = rfcomm_read_and_expect_char(rsock, result, expected)) < 1) {
+		return res;
+	}
+
+	rfcomm_append_buf(buf, count, in_count, *result);
+	return 1;
+}
+
+/*!
+ * \brief Read until '\r\n'.
+ * This function consumes the '\r\n' but does not add it to buf.
+ */
+static int rfcomm_read_until_crlf(int rsock, char **buf, size_t count, size_t *in_count)
+{
+	int res;
+	char c;
+
+	while ((res = read(rsock, &c, 1)) == 1) {
+		rfcomm_read_debug(c);
+		if (c == '\r') {
+			if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) == 1) {
+				break;
+			} else if (res == -2) {
+				rfcomm_append_buf(buf, count, in_count, '\r');
+			} else {
+				rfcomm_append_buf(buf, count, in_count, '\r');
+				break;
+			}
+		}
+
+		rfcomm_append_buf(buf, count, in_count, c);
+	}
+	return res;
+}
+
+/*!
+ * \brief Read the remainder of an AT SMS prompt.
+ * \note the entire parsed string is '\r\n> '
+ *
+ * By the time this function is executed, only a ' ' is left to read.
+ */
+static int rfcomm_read_sms_prompt(int rsock, char **buf, size_t count, size_t *in_count)
+{
+	int res;
+	if ((res = rfcomm_read_and_append_char(rsock, buf, count, in_count, NULL, ' ')) < 1)
+	       goto e_return;
+
+	return 1;
+
+e_return:
+	ast_log(LOG_ERROR, "error parsing SMS prompt on rfcomm socket\n");
+	return res;
+}
+
+/*!
+ * \brief Read and AT result code.
+ * \note the entire parsed string is '\r\n<result code>\r\n'
+ */
+static int rfcomm_read_result(int rsock, char **buf, size_t count, size_t *in_count)
+{
+	int res;
+	char c;
+
+	if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) < 1) {
+		goto e_return;
+	}
+
+	if ((res = rfcomm_read_and_append_char(rsock, buf, count, in_count, &c, '>')) == 1) {
+		return rfcomm_read_sms_prompt(rsock, buf, count, in_count);
+	} else if (res != -2) {
+		goto e_return;
+	}
+
+	rfcomm_append_buf(buf, count, in_count, c);
+	res = rfcomm_read_until_crlf(rsock, buf, count, in_count);
+
+	if (res != 1)
+		return res;
+
+	/* check for CMGR, which contains an embedded \r\n */
+	if (*in_count >= 5 && !strncmp(*buf - *in_count, "+CMGR", 5)) {
+		rfcomm_append_buf(buf, count, in_count, '\r');
+		rfcomm_append_buf(buf, count, in_count, '\n');
+		return rfcomm_read_until_crlf(rsock, buf, count, in_count);
+	}
+
+	return 1;
+
+e_return:
+	ast_log(LOG_ERROR, "error parsing AT result on rfcomm socket");
+	return res;
+}
+
+/*!
+ * \brief Read the remainder of an AT command.
+ * \note the entire parsed string is '<at command>\r'
+ */
+static int rfcomm_read_command(int rsock, char **buf, size_t count, size_t *in_count)
+{
+	int res;
+	char c;
+
+	while ((res = read(rsock, &c, 1)) == 1) {
+		rfcomm_read_debug(c);
+		/* stop when we get to '\r' */
+		if (c == '\r')
+			break;
+
+		rfcomm_append_buf(buf, count, in_count, c);
+	}
+	return res;
+}
+
+/*!
+ * \brief Read one Hayes AT message from an rfcomm socket.
+ * \param rsock the rfcomm socket to read from
+ * \param buf the buffer to store the result in
+ * \param count the size of the buffer or the maximum number of characters to read
+ *
+ * Here we need to read complete Hayes AT messages.  The AT message formats we
+ * support are listed below.
+ *
+ * \verbatim
+ * \r\n<result code>\r\n
+ * <at command>\r
+ * \r\n> 
+ * \endverbatim
+ *
+ * These formats correspond to AT result codes, AT commands, and the AT SMS
+ * prompt respectively.  When messages are read the leading and trailing '\r'
+ * and '\n' characters are discarded.  If the given buffer is not large enough
+ * to hold the response, what does not fit in the buffer will be dropped.
+ *
+ * \note The rfcomm connection to the device is asynchronous, so there is no
+ * guarantee that responses will be returned in a single read() call. We handle
+ * this by blocking until we can read an entire response.
+ *
+ * \retval 0 end of file
+ * \retval -1 read error
+ * \retval -2 parse error
+ * \retval other the number of characters added to buf
+ */
+static ssize_t rfcomm_read(int rsock, char *buf, size_t count)
+{
+	ssize_t res;
+	size_t in_count = 0;
+	char c;
+
+	if ((res = rfcomm_read_and_expect_char(rsock, &c, '\r')) == 1) {
+		res = rfcomm_read_result(rsock, &buf, count, &in_count);
+	} else if (res == -2) {
+		rfcomm_append_buf(&buf, count, &in_count, c);
+		res = rfcomm_read_command(rsock, &buf, count, &in_count);
+	}
+
+	if (res < 1)
+		return res;
+	else
+		return in_count;
+}
+
+/*
+
+	sco helpers and callbacks
+
+*/
+
+static int sco_connect(bdaddr_t src, bdaddr_t dst)
+{
+
+	struct sockaddr_sco addr;
+	int s;
+
+	if ((s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
+		ast_debug(1, "socket() failed (%d).\n", errno);
+		return -1;
+	}
+
+/* XXX this does not work with the do_sco_listen() thread (which also bind()s
+ * to this address).  Also I am not sure if it is necessary. */
+#if 0
+	memset(&addr, 0, sizeof(addr));
+	addr.sco_family = AF_BLUETOOTH;
+	bacpy(&addr.sco_bdaddr, &src);
+	if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		ast_debug(1, "bind() failed (%d).\n", errno);
+		close(s);
+		return -1;
+	}
+#endif
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sco_family = AF_BLUETOOTH;
+	bacpy(&addr.sco_bdaddr, &dst);
+
+	if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		ast_debug(1, "sco connect() failed (%d).\n", errno);
+		close(s);
+		return -1;
+	}
+
+	return s;
+
+}
+
+static int sco_write(int s, char *buf, int len)
+{
+
+	int r;
+
+	if (s == -1) {
+		ast_debug(3, "sco_write() not ready\n");
+		return 0;
+	}
+
+	ast_debug(3, "sco_write()\n");
+
+	r = write(s, buf, len);
+	if (r == -1) {
+		ast_debug(3, "sco write error %d\n", errno);
+		return 0;
+	}
+
+	return 1;
+
+}
+
+/*!
+ * \brief Accept SCO connections.
+ * This function is an ast_io callback function used to accept incoming sco
+ * audio connections.
+ */
+static int sco_accept(int *id, int fd, short events, void *data)
+{
+	struct adapter_pvt *adapter = (struct adapter_pvt *) data;
+	struct sockaddr_sco addr;
+	socklen_t addrlen;
+	struct mbl_pvt *pvt;
+	socklen_t len;
+	char saddr[18];
+	struct sco_options so;
+	int sock;
+
+	addrlen = sizeof(struct sockaddr_sco);
+	if ((sock = accept(fd, (struct sockaddr *)&addr, &addrlen)) == -1) {
+		ast_log(LOG_ERROR, "error accepting audio connection on adapter %s\n", adapter->id);
+		return 0;
+	}
+
+	len = sizeof(so);
+	getsockopt(sock, SOL_SCO, SCO_OPTIONS, &so, &len);
+
+	ba2str(&addr.sco_bdaddr, saddr);
+	ast_debug(1, "Incoming Audio Connection from device %s MTU is %d\n", saddr, so.mtu);
+
+	/* figure out which device this sco connection belongs to */
+	pvt = NULL;
+	AST_RWLIST_RDLOCK(&devices);
+	AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
+		if (!bacmp(&pvt->addr, &addr.sco_bdaddr))
+			break;
+	}
+	AST_RWLIST_UNLOCK(&devices);
+	if (!pvt) {
+		ast_log(LOG_WARNING, "could not find device for incoming audio connection\n");
+		close(sock);
+		return 1;
+	}
+
+	ast_mutex_lock(&pvt->lock);
+	if (pvt->sco_socket != -1) {
+		close(pvt->sco_socket);
+		pvt->sco_socket = -1;
+	}
+
+	pvt->sco_socket = sock;
+	if (pvt->owner) {
+		ast_channel_set_fd(pvt->owner, 0, sock);
+	} else {
+		ast_debug(1, "incoming audio connection for pvt without owner\n");
+	}
+
+	ast_mutex_unlock(&pvt->lock);
+
+	return 1;
+}
+
+/*!
+ * \brief Bind an SCO listener socket for the given adapter.
+ * \param adapter an adapter_pvt
+ * \return -1 on error, non zero on success
+ */
+static int sco_bind(struct adapter_pvt *adapter)
+{
+	struct sockaddr_sco addr;
+	int opt = 1;
+
+	if ((adapter->sco_socket = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
+		ast_log(LOG_ERROR, "Unable to create sco listener socket for adapter %s.\n", adapter->id);
+		goto e_return;
+	}
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sco_family = AF_BLUETOOTH;
+	bacpy(&addr.sco_bdaddr, &adapter->addr);
+	if (bind(adapter->sco_socket, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		ast_log(LOG_ERROR, "Unable to bind sco listener socket. (%d)\n", errno);
+		goto e_close_socket;
+	}
+	if (setsockopt(adapter->sco_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
+		ast_log(LOG_ERROR, "Unable to setsockopt sco listener socket.\n");
+		goto e_close_socket;
+	}
+	if (listen(adapter->sco_socket, 5) < 0) {
+		ast_log(LOG_ERROR, "Unable to listen sco listener socket.\n");
+		goto e_close_socket;
+	}
+
+	return adapter->sco_socket;
+
+e_close_socket:
+	close(adapter->sco_socket);
+	adapter->sco_socket = -1;
+e_return:
+	return -1;
+}
+
+
+/*
+ * Hayes AT command helpers.
+ */
+
+/*!
+ * \brief Match the given buffer with the given prefix.
+ * \param buf the buffer to match
+ * \param prefix the prefix to match
+ */
+static int at_match_prefix(char *buf, char *prefix)
+{
+	return !strncmp(buf, prefix, strlen(prefix));
+}
+
+/*!
+ * \brief Read an AT message and clasify it.
+ * \param rsock an rfcomm socket
+ * \param buf the buffer to store the result in
+ * \param count the size of the buffer or the maximum number of characters to read
+ * \return the type of message received, in addition buf will contain the
+ * message received and will be null terminated
+ * \see at_read()
+ */
+static at_message_t at_read_full(int rsock, char *buf, size_t count)
+{
+	ssize_t s;
+	if ((s = rfcomm_read(rsock, buf, count - 1)) < 1)
+		return s;
+	buf[s] = '\0';
+
+	if (!strcmp("OK", buf)) {
+		return AT_OK;
+	} else if (!strcmp("ERROR", buf)) {
+		return AT_ERROR;
+	} else if (!strcmp("RING", buf)) {
+		return AT_RING;
+	} else if (!strcmp("AT+CKPD=200", buf)) {
+		return AT_CKPD;
+	} else if (!strcmp("> ", buf)) {
+		return AT_SMS_PROMPT;
+	} else if (at_match_prefix(buf, "+CMTI:")) {
+		return AT_CMTI;
+	} else if (at_match_prefix(buf, "+CIEV:")) {
+		return AT_CIEV;
+	} else if (at_match_prefix(buf, "+BRSF:")) {
+		return AT_BRSF;
+	} else if (at_match_prefix(buf, "+CIND:")) {
+		return AT_CIND;
+	} else if (at_match_prefix(buf, "+CLIP:")) {
+		return AT_CLIP;
+	} else if (at_match_prefix(buf, "+CMGR:")) {
+		return AT_CMGR;
+	} else if (at_match_prefix(buf, "+VGM:")) {
+		return AT_VGM;
+	} else if (at_match_prefix(buf, "+VGS:")) {
+		return AT_VGS;
+	} else if (at_match_prefix(buf, "+CMS ERROR:")) {
+		return AT_CMS_ERROR;
+	} else if (at_match_prefix(buf, "AT+VGM=")) {
+		return AT_VGM;
+	} else if (at_match_prefix(buf, "AT+VGS=")) {
+		return AT_VGS;
+	} else {
+		return AT_UNKNOWN;
+	}
+}
+
+/*!
+ * \brief Get the string representation of the given AT message.
+ * \param msg the message to process
+ * \return a string describing the given message
+ */
+static inline const char *at_msg2str(at_message_t msg)
+{
+	switch (msg) {
+	/* errors */
+	case AT_PARSE_ERROR:
+		return "PARSE ERROR";
+	case AT_READ_ERROR:
+		return "READ ERROR";
+	default:
+	case AT_UNKNOWN:
+		return "UNKNOWN";
+	/* at responses */
+	case AT_OK:
+		return "OK";
+	case AT_ERROR:
+		return "ERROR";
+	case AT_RING:
+		return "RING";
+	case AT_BRSF:
+		return "AT+BRSF";
+	case AT_CIND:
+		return "AT+CIND";
+	case AT_CIEV:
+		return "AT+CIEV";
+	case AT_CLIP:
+		return "AT+CLIP";
+	case AT_CMTI:
+		return "AT+CMTI";
+	case AT_CMGR:
+		return "AT+CMGR";
+	case AT_SMS_PROMPT:
+		return "SMS PROMPT";
+	case AT_CMS_ERROR:
+		return "+CMS ERROR";
+	/* at commands */
+	case AT_A:
+		return "ATA";
+	case AT_D:
+		return "ATD";
+	case AT_CHUP:
+		return "AT+CHUP";
+	case AT_CKPD:
+		return "AT+CKPD";
+	case AT_CMGS:
+		return "AT+CMGS";
+	case AT_VGM:
+		return "AT+VGM";
+	case AT_VGS:
+		return "AT+VGS";
+	case AT_VTS:
+		return "AT+VTS";
+	case AT_CMGF:
+		return "AT+CMGF";
+	case AT_CNMI:
+		return "AT+CNMI";
+	case AT_CMER:
+		return "AT+CMER";
+	case AT_CIND_TEST:
+		return "AT+CIND=?";
+	}
+}
+
+
+/*
+ * bluetooth handsfree profile helpers
+ */
+
+/*!
+ * \brief Parse a CIEV event.
+ * \param hfp an hfp_pvt struct
+ * \param buf the buffer to parse (null terminated)
+ * \param value a pointer to an int to store the event value in (can be NULL)
+ * \return 0 on error (parse error, or unknown event) or a HFP_CIND_* value on
+ * success
+ */
+static int hfp_parse_ciev(struct hfp_pvt *hfp, char *buf, int *value)
+{
+	int i, v;
+	if (!value)
+		value = &v;
+
+	if (!sscanf(buf, "+CIEV: %d,%d", &i, value)) {
+		ast_debug(2, "[%s] error parsing CIEV event '%s'\n", hfp->owner->id, buf);
+		return HFP_CIND_NONE;
+	}
+
+	if (i >= sizeof(hfp->cind_state)) {
+		ast_debug(2, "[%s] CIEV event index too high (%s)\n", hfp->owner->id, buf);
+		return HFP_CIND_NONE;
+	}
+
+	hfp->cind_state[i] = *value;
+	return hfp->cind_index[i];
+}
+
+/*!
+ * \brief Parse a CLIP event.
+ * \param hfp an hfp_pvt struct
+ * \param buf the buffer to parse (null terminated)
+ * @note buf will be modified when the CID string is parsed
+ * \return NULL on error (parse error) or a pointer to the caller id
+ * inforamtion in buf
+ * success
+ */
+static char *hfp_parse_clip(struct hfp_pvt *hfp, char *buf)
+{
+	int i, state;
+	char *clip = NULL;
+	size_t s;
+
+	/* parse clip info in the following format:
+	 * +CLIP: "123456789",128,...
+	 */
+	state = 0;
+	s = strlen(buf);
+	for (i = 0; i < s && state != 3; i++) {
+		switch (state) {
+		case 0: /* search for start of the number (") */
+			if (buf[i] == '"') {
+				state++;
+			}
+			break;
+		case 1: /* mark the number */
+			clip = &buf[i];
+			state++;
+			/* fall through */
+		case 2: /* search for the end of the number (") */
+			if (buf[i] == '"') {
+				buf[i] = '\0';
+				state++;
+			}
+			break;
+		}
+	}
+
+	if (state != 3) {
+		return NULL;
+	}
+
+	return clip;
+}
+
+/*!
+ * \brief Parse a CMTI notification.
+ * \param hfp an hfp_pvt struct
+ * \param buf the buffer to parse (null terminated)
+ * @note buf will be modified when the CMTI message is parsed
+ * \return -1 on error (parse error) or the index of the new sms message
+ */
+static int hfp_parse_cmti(struct hfp_pvt *hfp, char *buf)
+{
+	int index = -1;
+
+	/* parse cmti info in the following format:
+	 * +CMTI: <mem>,<index> 
+	 */
+	if (!sscanf(buf, "+CMTI: %*[^,],%d", &index)) {
+		ast_debug(2, "[%s] error parsing CMTI event '%s'\n", hfp->owner->id, buf);
+		return -1;
+	}
+
+	return index;
+}
+
+/*!
+ * \brief Parse a CMGR message.
+ * \param hfp an hfp_pvt struct
+ * \param buf the buffer to parse (null terminated)
+ * \param from_number a pointer to a char pointer which will store the from
+ * number
+ * \param text a pointer to a char pointer which will store the message text
+ * @note buf will be modified when the CMGR message is parsed
+ * \retval -1 parse error
+ * \retval 0 success
+ */
+static int hfp_parse_cmgr(struct hfp_pvt *hfp, char *buf, char **from_number, char **text)
+{
+	int i, state;
+	size_t s;
+
+	/* parse cmgr info in the following format:
+	 * +CMGR: <msg status>,"+123456789",...\r\n
+	 * <message text>
+	 */
+	state = 0;
+	s = strlen(buf);
+	for (i = 0; i < s && s != 6; i++) {
+		switch (state) {
+		case 0: /* search for start of the number section (,) */
+			if (buf[i] == ',') {
+				state++;
+			}
+			break;
+		case 1: /* find the opening quote (") */
+			if (buf[i] == '"') {
+				state++;
+			}
+		case 2: /* mark the start of the number */
+			if (from_number) {
+				*from_number = &buf[i];
+				state++;
+			}
+			/* fall through */
+		case 3: /* search for the end of the number (") */
+			if (buf[i] == '"') {
+				buf[i] = '\0';
+				state++;
+			}
+			break;
+		case 4: /* search for the start of the message text (\n) */
+			if (buf[i] == '\n') {
+				state++;
+			}
+			break;
+		case 5: /* mark the start of the message text */
+			if (text) {
+				*text = &buf[i];
+				state++;
+			}
+			break;
+		}
+	}
+
+	if (state != 6) {
+		return -1;
+	}
+
+	return 0;
+}
+
+/*!
+ * \brief Convert a hfp_hf struct to a BRSF int.
+ * \param hf an hfp_hf brsf object
+ * \return an integer representing the given brsf struct
+ */
+static int hfp_brsf2int(struct hfp_hf *hf)
+{
+	int brsf = 0;
+
+	brsf |= hf->ecnr ? HFP_HF_ECNR : 0;
+	brsf |= hf->cw ? HFP_HF_CW : 0;
+	brsf |= hf->cid ? HFP_HF_CID : 0;
+	brsf |= hf->voice ? HFP_HF_VOICE : 0;
+	brsf |= hf->volume ? HFP_HF_VOLUME : 0;
+	brsf |= hf->status ? HFP_HF_STATUS : 0;
+	brsf |= hf->control ? HFP_HF_CONTROL : 0;
+
+	return brsf;
+}
+
+/*!
+ * \brief Convert a BRSF int to an hfp_ag struct.
+ * \param brsf a brsf integer
+ * \param ag a AG (hfp_ag) brsf object
+ * \return a pointer to the given hfp_ag object populated with the values from
+ * the given brsf integer
+ */
+static struct hfp_ag *hfp_int2brsf(int brsf, struct hfp_ag *ag)
+{
+	ag->cw = brsf & HFP_AG_CW ? 1 : 0;
+	ag->ecnr = brsf & HFP_AG_ECNR ? 1 : 0;
+	ag->voice = brsf & HFP_AG_VOICE ? 1 : 0;
+	ag->ring = brsf & HFP_AG_RING ? 1 : 0;
+	ag->tag = brsf & HFP_AG_TAG ? 1 : 0;
+	ag->reject = brsf & HFP_AG_REJECT ? 1 : 0;
+	ag->status = brsf & HFP_AG_STATUS ? 1 : 0;
+	ag->control = brsf & HFP_AG_CONTROL ? 1 : 0;
+	ag->errors = brsf & HFP_AG_ERRORS ? 1 : 0;
+
+	return ag;
+}
+
+
+/*!
+ * \brief Send a BRSF request.
+ * \param hfp an hfp_pvt struct
+ * \param brsf an hfp_hf brsf struct
+ *
+ * \retval 0 on success
+ * \retval -1 on error
+ */
+static int hfp_send_brsf(struct hfp_pvt *hfp, struct hfp_hf *brsf)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "AT+BRSF=%d\r", hfp_brsf2int(brsf));
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+/*!
+ * \brief Send the CIND read command.
+ * \param hfp an hfp_pvt struct
+ */
+static int hfp_send_cind(struct hfp_pvt *hfp)
+{
+	return rfcomm_write(hfp->rsock, "AT+CIND?\r");
+}
+
+/*!
+ * \brief Send the CIND test command.
+ * \param hfp an hfp_pvt struct
+ */
+static int hfp_send_cind_test(struct hfp_pvt *hfp)
+{
+	return rfcomm_write(hfp->rsock, "AT+CIND=?\r");
+}
+
+/*!
+ * \brief Enable or disable indicator events reporting.
+ * \param hfp an hfp_pvt struct
+ * \param status enable or disable events reporting (should be 1 or 0)
+ */
+static int hfp_send_cmer(struct hfp_pvt *hfp, int status)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "AT+CMER=3,0,0,%d\r", status ? 1 : 0);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+/*!
+ * \brief Send the current speaker gain level.
+ * \param hfp an hfp_pvt struct
+ * \param value the value to send (must be between 0 and 15)
+ */
+static int hfp_send_vgs(struct hfp_pvt *hfp, int value)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "AT+VGS=%d\r", value);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+#if 0
+/*!
+ * \brief Send the current microphone gain level.
+ * \param hfp an hfp_pvt struct
+ * \param value the value to send (must be between 0 and 15)
+ */
+static int hfp_send_vgm(struct hfp_pvt *hfp, int value)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "AT+VGM=%d\r", value);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+#endif
+
+/*!
+ * \brief Enable or disable calling line identification.
+ * \param hfp an hfp_pvt struct
+ * \param status enable or disable calling line identification (should be 1 or
+ * 0)
+ */
+static int hfp_send_clip(struct hfp_pvt *hfp, int status)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "AT+CLIP=%d\r", status ? 1 : 0);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+/*!
+ * \brief Send a DTMF command.
+ * \param hfp an hfp_pvt struct
+ * \param digit the dtmf digit to send
+ * \return the result of rfcomm_write() or -1 on an invalid digit being sent
+ */
+static int hfp_send_dtmf(struct hfp_pvt *hfp, char digit)
+{
+	char cmd[10];
+
+	switch(digit) {
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	case '*':
+	case '#':
+		snprintf(cmd, sizeof(cmd), "AT+VTS=%c\r", digit);
+		return rfcomm_write(hfp->rsock, cmd);
+	default:
+		return -1;
+	}
+}
+
+/*!
+ * \brief Set the SMS mode.
+ * \param hfp an hfp_pvt struct
+ * \param mode the sms mode (0 = PDU, 1 = Text)
+ */
+static int hfp_send_cmgf(struct hfp_pvt *hfp, int mode)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "AT+CMGF=%d\r", mode);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+/*!
+ * \brief Setup SMS new message indication.
+ * \param hfp an hfp_pvt struct
+ */
+static int hfp_send_cnmi(struct hfp_pvt *hfp)
+{
+	return rfcomm_write(hfp->rsock, "AT+CNMI=2,1,0,0,0\r");
+}
+
+/*!
+ * \brief Read an SMS message.
+ * \param hfp an hfp_pvt struct
+ * \param index the location of the requested message
+ */
+static int hfp_send_cmgr(struct hfp_pvt *hfp, int index)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "AT+CMGR=%d\r", index);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+/*!
+ * \brief Start sending an SMS message.
+ * \param hfp an hfp_pvt struct
+ * \param number the destination of the message
+ */
+static int hfp_send_cmgs(struct hfp_pvt *hfp, const char *number)
+{
+	char cmd[64];
+	snprintf(cmd, sizeof(cmd), "AT+CMGS=\"%s\"\r", number);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+/*!
+ * \brief Send the text of an SMS message.
+ * \param hfp an hfp_pvt struct
+ * \param message the text of the message
+ */
+static int hfp_send_sms_text(struct hfp_pvt *hfp, const char *message)
+{
+	char cmd[162];
+	snprintf(cmd, sizeof(cmd), "%.160s\x1a", message);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+/*!
+ * \brief Send AT+CHUP.
+ * \param hfp an hfp_pvt struct
+ */
+static int hfp_send_chup(struct hfp_pvt *hfp)
+{
+	return rfcomm_write(hfp->rsock, "AT+CHUP\r");
+}
+
+/*!
+ * \brief Send ATD.
+ * \param hfp an hfp_pvt struct
+ * \param number the number to send
+ */
+static int hfp_send_atd(struct hfp_pvt *hfp, const char *number)
+{
+	char cmd[64];
+	snprintf(cmd, sizeof(cmd), "ATD%s;\r", number);
+	return rfcomm_write(hfp->rsock, cmd);
+}
+
+/*!
+ * \brief Send ATA.
+ * \param hfp an hfp_pvt struct
+ */
+static int hfp_send_ata(struct hfp_pvt *hfp)
+{
+	return rfcomm_write(hfp->rsock, "ATA\r");
+}
+
+/*!
+ * \brief Parse BRSF data.
+ * \param hfp an hfp_pvt struct
+ * \param buf the buffer to parse (null terminated)
+ */
+static int hfp_parse_brsf(struct hfp_pvt *hfp, const char *buf)
+{
+	int brsf;
+
+	if (!sscanf(buf, "+BRSF:%d", &brsf))
+		return -1;
+
+	hfp_int2brsf(brsf, &hfp->brsf);
+
+	return 0;
+}
+
+/*!
+ * \brief Parse and store the given indicator.
+ * \param hfp an hfp_pvt struct
+ * \param group the indicator group
+ * \param indicator the indicator to parse
+ */
+static int hfp_parse_cind_indicator(struct hfp_pvt *hfp, int group, char *indicator)
+{
+	int value;
+
+	/* store the current indicator */
+	if (group >= sizeof(hfp->cind_state)) {
+		ast_debug(1, "ignoring CIND state '%s' for group %d, we only support up to %d indicators\n", indicator, group, (int) sizeof(hfp->cind_state));
+		return -1;
+	}
+
+	if (!sscanf(indicator, "%d", &value)) {
+		ast_debug(1, "error parsing CIND state '%s' for group %d\n", indicator, group);
+		return -1;
+	}
+
+	hfp->cind_state[group] = value;
+	return 0;
+}
+
+/*!
+ * \brief Read the result of the AT+CIND? command.
+ * \param hfp an hfp_pvt struct
+ * \param buf the buffer to parse (null terminated)
+ * \note hfp_send_cind_test() and hfp_parse_cind_test() should be called at
+ * least once before this function is called.
+ */
+static int hfp_parse_cind(struct hfp_pvt *hfp, char *buf)
+{
+	int i, state, group;
+	size_t s;
+	char *indicator = NULL;
+
+	/* parse current state of all of our indicators.  The list is in the
+	 * following format:
+	 * +CIND: 1,0,2,0,0,0,0
+	 */
+	group = 0;
+	state = 0;
+	s = strlen(buf);
+	for (i = 0; i < s; i++) {
+		switch (state) {
+		case 0: /* search for start of the status indicators (a space) */
+			if (buf[i] == ' ') {
+				group++;
+				state++;
+			}
+			break;
+		case 1: /* mark this indicator */
+			indicator = &buf[i];
+			state++;
+			break;
+		case 2: /* search for the start of the next indicator (a comma) */
+			if (buf[i] == ',') {
+				buf[i] = '\0';
+
+				hfp_parse_cind_indicator(hfp, group, indicator);
+
+				group++;
+				state = 1;
+			}
+			break;
+		}
+	}
+
+	/* store the last indicator */
+	if (state == 2)
+		hfp_parse_cind_indicator(hfp, group, indicator);
+
+	return 0;
+}
+
+/*!
+ * \brief Parse the result of the AT+CIND=? command.
+ * \param hfp an hfp_pvt struct
+ * \param buf the buffer to parse (null terminated)
+ */
+static int hfp_parse_cind_test(struct hfp_pvt *hfp, char *buf)
+{
+	int i, state, group;
+	size_t s;
+	char *indicator = NULL, *values;
+
+	hfp->nocallsetup = 1;
+
+	/* parse the indications list.  It is in the follwing format:
+	 * +CIND: ("ind1",(0-1)),("ind2",(0-5))
+	 */
+	group = 0;
+	state = 0;
+	s = strlen(buf);
+	for (i = 0; i < s; i++) {
+		switch (state) {
+		case 0: /* search for start of indicator block */
+			if (buf[i] == '(') {
+				group++;
+				state++;
+			}
+			break;
+		case 1: /* search for '"' in indicator block */
+			if (buf[i] == '"') {
+				state++;
+			}
+			break;
+		case 2: /* mark the start of the indicator name */
+			indicator = &buf[i];
+			state++;
+			break;
+		case 3: /* look for the end of the indicator name */
+			if (buf[i] == '"') {
+				buf[i] = '\0';
+				state++;
+			}
+			break;
+		case 4: /* find the start of the value range */
+			if (buf[i] == '(') {
+				state++;
+			}
+			break;
+		case 5: /* mark the start of the value range */
+			values = &buf[i];
+			state++;
+			break;
+		case 6: /* find the end of the value range */
+			if (buf[i] == ')') {
+				buf[i] = '\0';
+				state++;
+			}
+			break;
+		case 7: /* process the values we found */
+			if (group < sizeof(hfp->cind_index)) {
+				if (!strcmp(indicator, "service")) {
+					hfp->cind_map.service = group;
+					hfp->cind_index[group] = HFP_CIND_SERVICE;
+				} else if (!strcmp(indicator, "call")) {
+					hfp->cind_map.call = group;
+					hfp->cind_index[group] = HFP_CIND_CALL;
+				} else if (!strcmp(indicator, "callsetup")) {
+					hfp->nocallsetup = 0;
+					hfp->cind_map.callsetup = group;
+					hfp->cind_index[group] = HFP_CIND_CALLSETUP;
+				} else if (!strcmp(indicator, "call_setup")) { /* non standard call setup identifier */
+					hfp->nocallsetup = 0;
+					hfp->cind_map.callsetup = group;
+					hfp->cind_index[group] = HFP_CIND_CALLSETUP;
+				} else if (!strcmp(indicator, "callheld")) {
+					hfp->cind_map.callheld = group;
+					hfp->cind_index[group] = HFP_CIND_CALLHELD;
+				} else if (!strcmp(indicator, "signal")) {
+					hfp->cind_map.signal = group;
+					hfp->cind_index[group] = HFP_CIND_SIGNAL;
+				} else if (!strcmp(indicator, "roam")) {
+					hfp->cind_map.roam = group;
+					hfp->cind_index[group] = HFP_CIND_ROAM;
+				} else if (!strcmp(indicator, "battchg")) {
+					hfp->cind_map.battchg = group;
+					hfp->cind_index[group] = HFP_CIND_BATTCHG;
+				} else {
+					hfp->cind_index[group] = HFP_CIND_UNKNOWN;
+					ast_debug(2, "ignoring unknown CIND indicator '%s'\n", indicator);
+				}
+			} else {
+					ast_debug(1, "can't store indicator %d (%s), we only support up to %d indicators", group, indicator, (int) sizeof(hfp->cind_index));
+			}
+
+			state = 0;
+			break;
+		}
+	}
+
+	hfp->owner->no_callsetup = hfp->nocallsetup;
+
+	return 0;
+}
+
+
+/*
+ * Bluetooth Headset Profile helpers
+ */
+
+/*!
+ * \brief Send an OK AT response.
+ * \param rsock the rfcomm socket to use
+ */
+static int hsp_send_ok(int rsock)
+{
+	return rfcomm_write(rsock, "\r\nOK\r\n");
+}
+
+/*!
+ * \brief Send an ERROR AT response.
+ * \param rsock the rfcomm socket to use
+ */
+static int hsp_send_error(int rsock)
+{
+	return rfcomm_write(rsock, "\r\nERROR\r\n");
+}
+
+/*!
+ * \brief Send a speaker gain unsolicited AT response
+ * \param rsock the rfcomm socket to use
+ * \param gain the speaker gain value
+ */
+static int hsp_send_vgs(int rsock, int gain)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "\r\n+VGS=%d\r\n", gain);
+	return rfcomm_write(rsock, cmd);
+}
+
+/*!
+ * \brief Send a microphone gain unsolicited AT response
+ * \param rsock the rfcomm socket to use
+ * \param gain the microphone gain value
+ */
+static int hsp_send_vgm(int rsock, int gain)
+{
+	char cmd[32];
+	snprintf(cmd, sizeof(cmd), "\r\n+VGM=%d\r\n", gain);
+	return rfcomm_write(rsock, cmd);
+}
+
+/*!
+ * \brief Send a RING unsolicited AT response.
+ * \param rsock the rfcomm socket to use
+ */
+static int hsp_send_ring(int rsock)
+{
+	return rfcomm_write(rsock, "\r\nRING\r\n");
+}
+
+/*
+ * message queue functions
+ */
+
+/*!
+ * \brief Add an item to the back of the queue.
+ * \param pvt a mbl_pvt structure
+ * \param expect the msg we expect to recieve
+ * \param response_to the message that was sent to generate the expected
+ * response
+ */
+static int msg_queue_push(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to)
+{
+	struct msg_queue_entry *msg;
+	if (!(msg = ast_calloc(1, sizeof(*msg)))) {
+		return -1;
+	}
+	msg->expected = expect;
+	msg->response_to = response_to;
+
+	AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry);
+	return 0;
+}
+
+/*!
+ * \brief Add an item to the back of the queue with data.
+ * \param pvt a mbl_pvt structure
+ * \param expect the msg we expect to recieve
+ * \param response_to the message that was sent to generate the expected
+ * response
+ * \param data data associated with this message, it will be freed when the
+ * message is freed
+ */
+static int msg_queue_push_data(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to, void *data)
+{
+	struct msg_queue_entry *msg;
+	if (!(msg = ast_calloc(1, sizeof(*msg)))) {
+		return -1;
+	}
+	msg->expected = expect;
+	msg->response_to = response_to;
+	msg->data = data;
+
+	AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry);
+	return 0;
+}
+
+/*!
+ * \brief Remove an item from the front of the queue.
+ * \param pvt a mbl_pvt structure
+ * \return a pointer to the removed item
+ */
+static struct msg_queue_entry *msg_queue_pop(struct mbl_pvt *pvt)
+{
+	return AST_LIST_REMOVE_HEAD(&pvt->msg_queue, entry);
+}
+
+/*!
+ * \brief Remove an item from the front of the queue, and free it.
+ * \param pvt a mbl_pvt structure
+ */
+static void msg_queue_free_and_pop(struct mbl_pvt *pvt)
+{
+	struct msg_queue_entry *msg;
+	if ((msg = msg_queue_pop(pvt))) {
+		if (msg->data)
+			ast_free(msg->data);
+		ast_free(msg);
+	}
+}
+
+/*!
+ * \brief Remove all itmes from the queue and free them.
+ * \param pvt a mbl_pvt structure
+ */
+static void msg_queue_flush(struct mbl_pvt *pvt)
+{
+	struct msg_queue_entry *msg;
+	while ((msg = msg_queue_head(pvt)))
+		msg_queue_free_and_pop(pvt);
+}
+
+/*!
+ * \brief Get the head of a queue.
+ * \param pvt a mbl_pvt structure
+ * \return a pointer to the head of the given msg queue
+ */
+static struct msg_queue_entry *msg_queue_head(struct mbl_pvt *pvt)
+{
+	return AST_LIST_FIRST(&pvt->msg_queue);
+}
+
+
+
+/*
+
+	sdp helpers
+
+*/
+
+static int sdp_search(char *addr, int profile)
+{
+
+	sdp_session_t *session = 0;
+	bdaddr_t bdaddr;
+	uuid_t svc_uuid;
+	uint32_t range = 0x0000ffff;
+	sdp_list_t *response_list, *search_list, *attrid_list;
+	int status, port;
+	sdp_list_t *proto_list;
+	sdp_record_t *sdprec;
+
+	str2ba(addr, &bdaddr);
+	port = 0;
+	session = sdp_connect(BDADDR_ANY, &bdaddr, SDP_RETRY_IF_BUSY);
+	if (!session) {
+		ast_debug(1, "sdp_connect() failed on device %s.\n", addr);
+		return 0;
+	}
+
+	sdp_uuid32_create(&svc_uuid, profile);
+	search_list = sdp_list_append(0, &svc_uuid);
+	attrid_list = sdp_list_append(0, &range);
+	response_list = 0x00;
+	status = sdp_service_search_attr_req(session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
+	if (status == 0) {
+		if (response_list) {
+			sdprec = (sdp_record_t *) response_list->data;
+			proto_list = 0x00;
+			if (sdp_get_access_protos(sdprec, &proto_list) == 0) {
+				port = sdp_get_proto_port(proto_list, RFCOMM_UUID);
+				sdp_list_free(proto_list, 0);
+			}
+			sdp_record_free(sdprec);
+			sdp_list_free(response_list, 0);
+		} else
+			ast_debug(1, "No responses returned for device %s.\n", addr);
+	} else
+		ast_debug(1, "sdp_service_search_attr_req() failed on device %s.\n", addr);
+
+	sdp_list_free(search_list, 0);
+	sdp_list_free(attrid_list, 0);
+	sdp_close(session);
+
+	return port;
+
+}
+
+static sdp_session_t *sdp_register(void)
+{
+
+	uint32_t service_uuid_int[] = {0, 0, 0, GENERIC_AUDIO_SVCLASS_ID};
+	uint8_t rfcomm_channel = 1;
+	const char *service_name = "Asterisk PABX";
+	const char *service_dsc = "Asterisk PABX";
+	const char *service_prov = "Asterisk";
+
+	uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid, svc_class1_uuid, svc_class2_uuid;
+	sdp_list_t  *l2cap_list = 0, *rfcomm_list = 0, *root_list = 0, *proto_list = 0, *access_proto_list = 0, *svc_uuid_list = 0;
+	sdp_data_t *channel = 0;
+
+	int err = 0;
+	sdp_session_t *session = 0;
+
+	sdp_record_t *record = sdp_record_alloc();
+
+	sdp_uuid128_create(&svc_uuid, &service_uuid_int);
+	sdp_set_service_id(record, svc_uuid);
+
+	sdp_uuid32_create(&svc_class1_uuid, GENERIC_AUDIO_SVCLASS_ID);
+	sdp_uuid32_create(&svc_class2_uuid, HEADSET_PROFILE_ID);
+
+	svc_uuid_list = sdp_list_append(0, &svc_class1_uuid);
+	svc_uuid_list = sdp_list_append(svc_uuid_list, &svc_class2_uuid);
+	sdp_set_service_classes(record, svc_uuid_list);
+
+	sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
+	root_list = sdp_list_append(0, &root_uuid);
+	sdp_set_browse_groups( record, root_list );
+
+	sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
+	l2cap_list = sdp_list_append(0, &l2cap_uuid);
+	proto_list = sdp_list_append(0, l2cap_list);
+
+	sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
+	channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
+	rfcomm_list = sdp_list_append(0, &rfcomm_uuid);
+	sdp_list_append(rfcomm_list, channel);
+	sdp_list_append(proto_list, rfcomm_list);
+
+	access_proto_list = sdp_list_append(0, proto_list);
+	sdp_set_access_protos(record, access_proto_list);
+
+	sdp_set_info_attr(record, service_name, service_prov, service_dsc);
+
+	if (!(session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY)))
+		ast_log(LOG_WARNING, "Failed to connect sdp and create session.\n");
+	else
+		err = sdp_record_register(session, record, 0);
+
+	sdp_data_free(channel);
+	sdp_list_free(rfcomm_list, 0);
+	sdp_list_free(root_list, 0);
+	sdp_list_free(access_proto_list, 0);
+	sdp_list_free(svc_uuid_list, 0);
+
+	return session;
+
+}
+
+/*
+
+	Thread routines
+
+*/
+
+/*!
+ * \brief Handle the BRSF response.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_brsf(struct mbl_pvt *pvt, char *buf)
+{
+	struct msg_queue_entry *entry;
+	if ((entry = msg_queue_head(pvt)) && entry->expected == AT_BRSF) {
+		if (hfp_parse_brsf(pvt->hfp, buf)) {
+			ast_debug(1, "[%s] error parsing BRSF\n", pvt->id);
+			goto e_return;
+		}
+
+		if (msg_queue_push(pvt, AT_OK, AT_BRSF)) {
+			ast_debug(1, "[%s] error handling BRSF\n", pvt->id);
+			goto e_return;
+		}
+
+		msg_queue_free_and_pop(pvt);
+	} else if (entry) {
+		ast_debug(1, "[%s] recieved unexpected AT message 'BRSF' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
+	} else {
+		ast_debug(1, "[%s] recieved unexpected AT message 'BRSF'\n", pvt->id);
+	}
+
+	return 0;
+
+e_return:
+	msg_queue_free_and_pop(pvt);
+	return -1;
+}
+
+/*!
+ * \brief Handle the CIND response.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_cind(struct mbl_pvt *pvt, char *buf)
+{
+	struct msg_queue_entry *entry;
+	if ((entry = msg_queue_head(pvt)) && entry->expected == AT_CIND) {
+		switch (entry->response_to) {
+		case AT_CIND_TEST:
+			if (hfp_parse_cind_test(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND_TEST)) {
+				ast_debug(1, "[%s] error performing CIND test\n", pvt->id);
+				goto e_return;
+			}
+			break;
+		case AT_CIND:
+			if (hfp_parse_cind(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND)) {
+				ast_debug(1, "[%s] error getting CIND state\n", pvt->id);
+				goto e_return;
+			}
+			break;
+		default:
+			ast_debug(1, "[%s] error getting CIND state\n", pvt->id);
+			goto e_return;
+		}
+		msg_queue_free_and_pop(pvt);
+	} else if (entry) {
+		ast_debug(1, "[%s] recieved unexpected AT message 'CIND' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
+	} else {
+		ast_debug(1, "[%s] recieved unexpected AT message 'CIND'\n", pvt->id);
+	}
+
+	return 0;
+
+e_return:
+	msg_queue_free_and_pop(pvt);
+	return -1;
+}
+
+/*!
+ * \brief Handle OK AT messages.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_ok(struct mbl_pvt *pvt, char *buf)
+{
+	struct msg_queue_entry *entry;
+	if ((entry = msg_queue_head(pvt)) && entry->expected == AT_OK) {
+		switch (entry->response_to) {
+
+		/* initilization stuff */
+		case AT_BRSF:
+			ast_debug(1, "[%s] BSRF sent successfully\n", pvt->id);
+
+			/* If this is a blackberry do CMER now, otherwise
+			 * continue with CIND as normal. */
+			if (pvt->blackberry) {
+				if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) {
+					ast_debug(1, "[%s] error sending CMER\n", pvt->id);
+					goto e_return;
+				}
+			} else {
+				if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) {
+					ast_debug(1, "[%s] error sending CIND test\n", pvt->id);
+					goto e_return;
+				}
+			}
+			break;
+		case AT_CIND_TEST:
+			ast_debug(1, "[%s] CIND test sent successfully\n", pvt->id);
+
+			ast_debug(2, "[%s] call: %d\n", pvt->id, pvt->hfp->cind_map.call);
+			ast_debug(2, "[%s] callsetup: %d\n", pvt->id, pvt->hfp->cind_map.callsetup);
+
+			if (hfp_send_cind(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND)) {
+				ast_debug(1, "[%s] error requesting CIND state\n", pvt->id);
+				goto e_return;
+			}
+			break;
+		case AT_CIND:
+			ast_debug(1, "[%s] CIND sent successfully\n", pvt->id);
+
+			/* check if a call is active */
+			if (pvt->hfp->cind_state[pvt->hfp->cind_map.call]) {
+				ast_verb(3, "Bluetooth Device %s has a call in progress - delaying connection.\n", pvt->id);
+				goto e_return;
+			}
+
+			/* If this is NOT a blackberry proceed with CMER,
+			 * otherwise send CLIP. */
+			if (!pvt->blackberry) {
+				if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) {
+					ast_debug(1, "[%s] error sending CMER\n", pvt->id);
+					goto e_return;
+				}
+			} else {
+				if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) {
+					ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id);
+					goto e_return;
+				}
+			}
+			break;
+		case AT_CMER:
+			ast_debug(1, "[%s] CMER sent successfully\n", pvt->id);
+
+			/* If this is a blackberry proceed with the CIND test,
+			 * otherwise send CLIP. */
+			if (pvt->blackberry) {
+				if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) {
+					ast_debug(1, "[%s] error sending CIND test\n", pvt->id);
+					goto e_return;
+				}
+			} else {
+				if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) {
+					ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id);
+					goto e_return;
+				}
+			}
+			break;
+		case AT_CLIP:
+			ast_debug(1, "[%s] caling line indication enabled\n", pvt->id);
+			if (hfp_send_vgs(pvt->hfp, 15) || msg_queue_push(pvt, AT_OK, AT_VGS)) {
+				ast_debug(1, "[%s] error synchronizing gain settings\n", pvt->id);
+				goto e_return;
+			}
+
+			pvt->timeout = -1;
+			pvt->hfp->initialized = 1;
+			ast_verb(3, "Bluetooth Device %s initialized and ready.\n", pvt->id);
+
+			break;
+		case AT_VGS:
+			ast_debug(1, "[%s] volume level synchronization successful\n", pvt->id);
+
+			/* set the SMS operating mode to text mode */
+			if (hfp_send_cmgf(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMGF)) {
+				ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
+				goto e_return;
+			}
+			break;
+		case AT_CMGF:
+			ast_debug(1, "[%s] sms text mode enabled\n", pvt->id);
+			/* turn on SMS new message indication */
+			if (hfp_send_cnmi(pvt->hfp) || msg_queue_push(pvt, AT_OK, AT_CNMI)) {
+				ast_debug(1, "[%s] error setting CNMI\n", pvt->id);
+				goto e_return;
+			}
+			break;
+		case AT_CNMI:
+			ast_debug(1, "[%s] sms new message indication enabled\n", pvt->id);
+			pvt->has_sms = 1;
+			break;
+		/* end initilization stuff */
+
+		case AT_A:
+			ast_debug(1, "[%s] answer sent successfully\n", pvt->id);
+			pvt->needchup = 1;
+			break;
+		case AT_D:
+			ast_debug(1, "[%s] dial sent successfully\n", pvt->id);
+			pvt->needchup = 1;
+			pvt->outgoing = 1;
+			mbl_queue_control(pvt, AST_CONTROL_PROGRESS);
+			break;
+		case AT_CHUP:
+			ast_debug(1, "[%s] successful hangup\n", pvt->id);
+			break;
+		case AT_CMGR:
+			ast_debug(1, "[%s] successfully read sms message\n", pvt->id);
+			pvt->incoming_sms = 0;
+			break;
+		case AT_CMGS:
+			ast_debug(1, "[%s] successfully sent sms message\n", pvt->id);
+			pvt->outgoing_sms = 0;
+			break;
+		case AT_VTS:
+			ast_debug(1, "[%s] digit sent successfully\n", pvt->id);
+			break;
+		case AT_UNKNOWN:
+		default:
+			ast_debug(1, "[%s] recieved OK for unhandled request: %s\n", pvt->id, at_msg2str(entry->response_to));
+			break;
+		}
+		msg_queue_free_and_pop(pvt);
+	} else if (entry) {
+		ast_debug(1, "[%s] recieved AT message 'OK' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
+	} else {
+		ast_debug(1, "[%s] recieved unexpected AT message 'OK'\n", pvt->id);
+	}
+	return 0;
+
+e_return:
+	msg_queue_free_and_pop(pvt);
+	return -1;
+}
+
+/*!
+ * \brief Handle ERROR AT messages.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_error(struct mbl_pvt *pvt, char *buf)
+{
+	struct msg_queue_entry *entry;
+	if ((entry = msg_queue_head(pvt))
+			&& (entry->expected == AT_OK
+			|| entry->expected == AT_ERROR
+			|| entry->expected == AT_CMS_ERROR
+			|| entry->expected == AT_CMGR
+			|| entry->expected == AT_SMS_PROMPT)) {
+		switch (entry->response_to) {
+
+		/* initilization stuff */
+		case AT_BRSF:
+			ast_debug(1, "[%s] error reading BSRF\n", pvt->id);
+			goto e_return;
+		case AT_CIND_TEST:
+			ast_debug(1, "[%s] error during CIND test\n", pvt->id);
+			goto e_return;
+		case AT_CIND:
+			ast_debug(1, "[%s] error requesting CIND state\n", pvt->id);
+			goto e_return;
+		case AT_CMER:
+			ast_debug(1, "[%s] error during CMER request\n", pvt->id);
+			goto e_return;
+		case AT_CLIP:
+			ast_debug(1, "[%s] error enabling calling line indication\n", pvt->id);
+			goto e_return;
+		case AT_VGS:
+			ast_debug(1, "[%s] volume level synchronization failed\n", pvt->id);
+
+			/* this is not a fatal error, let's continue with initilization */
+
+			/* set the SMS operating mode to text mode */
+			if (hfp_send_cmgf(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMGF)) {
+				ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
+				goto e_return;
+			}
+			break;
+		case AT_CMGF:
+			ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
+			ast_debug(1, "[%s] no SMS support\n", pvt->id);
+			break;
+		case AT_CNMI:
+			ast_debug(1, "[%s] error setting CNMI\n", pvt->id);
+			ast_debug(1, "[%s] no SMS support\n", pvt->id);
+			break;
+		/* end initilization stuff */
+
+		case AT_A:
+			ast_debug(1, "[%s] answer failed\n", pvt->id);
+			mbl_queue_hangup(pvt);
+			break;
+		case AT_D:
+			ast_debug(1, "[%s] dial failed\n", pvt->id);
+			pvt->needchup = 0;
+			mbl_queue_control(pvt, AST_CONTROL_CONGESTION);
+			break;
+		case AT_CHUP:
+			ast_debug(1, "[%s] error sending hangup, disconnecting\n", pvt->id);
+			goto e_return;
+		case AT_CMGR:
+			ast_debug(1, "[%s] error reading sms message\n", pvt->id);
+			pvt->incoming_sms = 0;
+			break;
+		case AT_CMGS:
+			ast_debug(1, "[%s] error sending sms message\n", pvt->id);
+			pvt->outgoing_sms = 0;
+			break;
+		case AT_VTS:
+			ast_debug(1, "[%s] error sending digit\n", pvt->id);
+			break;
+		case AT_UNKNOWN:
+		default:
+			ast_debug(1, "[%s] recieved ERROR for unhandled request: %s\n", pvt->id, at_msg2str(entry->response_to));
+			break;
+		}
+		msg_queue_free_and_pop(pvt);
+	} else if (entry) {
+		ast_debug(1, "[%s] recieved AT message 'ERROR' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
+	} else {
+		ast_debug(1, "[%s] recieved unexpected AT message 'ERROR'\n", pvt->id);
+	}
+
+	return 0;
+
+e_return:
+	msg_queue_free_and_pop(pvt);
+	return -1;
+}
+
+/*!
+ * \brief Handle AT+CIEV messages.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_ciev(struct mbl_pvt *pvt, char *buf)
+{
+	int i;
+	switch (hfp_parse_ciev(pvt->hfp, buf, &i)) {
+	case HFP_CIND_CALL:
+		switch (i) {
+		case HFP_CIND_CALL_NONE:
+			ast_debug(1, "[%s] line disconnected\n", pvt->id);
+			if (pvt->owner) {
+				ast_debug(1, "[%s] hanging up owner\n", pvt->id);
+				if (mbl_queue_hangup(pvt)) {
+					ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnectiong...\n", pvt->id);
+					return -1;
+				}
+			}
+			pvt->needchup = 0;
+			pvt->needcallerid = 0;
+			pvt->incoming = 0;
+			pvt->outgoing = 0;
+			break;
+		case HFP_CIND_CALL_ACTIVE:
+			if (pvt->outgoing) {
+				ast_debug(1, "[%s] remote end answered\n", pvt->id);
+				mbl_queue_control(pvt, AST_CONTROL_ANSWER);
+			} else if (pvt->incoming && pvt->answered) {
+				ast_setstate(pvt->owner, AST_STATE_UP);
+			} else if (pvt->incoming) {
+				/* user answered from handset, disconnecting */
+				ast_verb(3, "[%s] user answered bluetooth device from handset, disconnecting\n", pvt->id);
+				mbl_queue_hangup(pvt);
+				return -1;
+			}
+			break;
+		}
+		break;
+
+	case HFP_CIND_CALLSETUP:
+		switch (i) {
+		case HFP_CIND_CALLSETUP_NONE:
+			if (pvt->hfp->cind_state[pvt->hfp->cind_map.call] != HFP_CIND_CALL_ACTIVE) {
+				if (pvt->owner) {
+					if (mbl_queue_hangup(pvt)) {
+						ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnectiong...\n", pvt->id);
+						return -1;
+					}
+				}
+				pvt->needchup = 0;
+				pvt->needcallerid = 0;
+				pvt->incoming = 0;
+				pvt->outgoing = 0;
+			}
+			break;
+		case HFP_CIND_CALLSETUP_INCOMING:
+			ast_debug(1, "[%s] incoming call, waiting for caller id\n", pvt->id);
+			pvt->needcallerid = 1;
+			pvt->incoming = 1;
+			break;
+		case HFP_CIND_CALLSETUP_OUTGOING:
+			if (pvt->outgoing) {
+				ast_debug(1, "[%s] outgoing call\n", pvt->id);
+			} else {
+				ast_verb(3, "[%s] user dialed from handset, disconnecting\n", pvt->id);
+				return -1;
+			}
+			break;
+		case HFP_CIND_CALLSETUP_ALERTING:
+			if (pvt->outgoing) {
+				ast_debug(1, "[%s] remote alerting\n", pvt->id);
+				mbl_queue_control(pvt, AST_CONTROL_RINGING);
+			}
+			break;
+		}
+		break;
+	case HFP_CIND_NONE:
+		ast_debug(1, "[%s] error parsing CIND: %s\n", pvt->id, buf);
+		break;
+	}
+	return 0;
+}
+
+/*!
+ * \brief Handle AT+CLIP messages.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_clip(struct mbl_pvt *pvt, char *buf)
+{
+	char *clip;
+	struct msg_queue_entry *msg;
+	struct ast_channel *chan;
+
+	if ((msg = msg_queue_head(pvt)) && msg->expected == AT_CLIP) {
+		msg_queue_free_and_pop(pvt);
+
+		pvt->needcallerid = 0;
+		if (!(clip = hfp_parse_clip(pvt->hfp, buf))) {
+			ast_debug(1, "[%s] error parsing CLIP: %s\n", pvt->id, buf);
+		}
+
+		if (!(chan = mbl_new(AST_STATE_RING, pvt, clip, NULL))) {
+			ast_log(LOG_ERROR, "[%s] unable to allocate channel for incoming call\n", pvt->id);
+			hfp_send_chup(pvt->hfp);
+			msg_queue_push(pvt, AT_OK, AT_CHUP);
+			return -1;
+		}
+
+		/* from this point on, we need to send a chup in the event of a
+		 * hangup */
+		pvt->needchup = 1;
+
+		if (ast_pbx_start(chan)) {
+			ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming call\n", pvt->id);
+			mbl_ast_hangup(pvt);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+/*!
+ * \brief Handle RING messages.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_ring(struct mbl_pvt *pvt, char *buf)
+{
+	if (pvt->needcallerid) {
+		ast_debug(1, "[%s] got ring while waiting for caller id\n", pvt->id);
+		return msg_queue_push(pvt, AT_CLIP, AT_UNKNOWN);
+	} else {
+		return 0;
+	}
+}
+
+/*!
+ * \brief Handle AT+CMTI messages.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_cmti(struct mbl_pvt *pvt, char *buf)
+{
+	int index = hfp_parse_cmti(pvt->hfp, buf);
+	if (index > 0) {
+		ast_debug(1, "[%s] incoming sms message\n", pvt->id);
+
+		if (hfp_send_cmgr(pvt->hfp, index)
+				|| msg_queue_push(pvt, AT_CMGR, AT_CMGR)) {
+			ast_debug(1, "[%s] error sending CMGR to retrieve SMS message\n", pvt->id);
+			return -1;
+		}
+
+		pvt->incoming_sms = 1;
+		return 0;
+	} else {
+		ast_debug(1, "[%s] error parsing incoming sms message alert, disconnecting\n", pvt->id);
+		return -1;
+	}
+}
+
+/*!
+ * \brief Handle AT+CMGR messages.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_response_cmgr(struct mbl_pvt *pvt, char *buf)
+{
+	char *from_number = NULL, *text = NULL;
+	struct ast_channel *chan;
+	struct msg_queue_entry *msg;
+
+	if ((msg = msg_queue_head(pvt)) && msg->expected == AT_CMGR) {
+		msg_queue_free_and_pop(pvt);
+
+		if (hfp_parse_cmgr(pvt->hfp, buf, &from_number, &text)
+				|| msg_queue_push(pvt, AT_OK, AT_CMGR)) {
+
+			ast_debug(1, "[%s] error parsing sms message, disconnecting\n", pvt->id);
+			return -1;
+		}
+
+		/* XXX this channel probably does not need to be associated with this pvt */
+		if (!(chan = mbl_new(AST_STATE_DOWN, pvt, NULL, NULL))) {
+			ast_debug(1, "[%s] error creating sms message channel, disconnecting\n", pvt->id);
+			return -1;
+		}
+
+		strcpy(chan->exten, "sms");
+		pbx_builtin_setvar_helper(chan, "SMSSRC", from_number);
+		pbx_builtin_setvar_helper(chan, "SMSTXT", text);
+
+		if (ast_pbx_start(chan)) {
+			ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming sms\n", pvt->id);
+			mbl_ast_hangup(pvt);
+		}
+	} else {
+		ast_debug(1, "[%s] got unexpected +CMGR message, ignoring\n", pvt->id);
+	}
+
+	return 0;
+}
+
+/*!
+ * \brief Send an SMS message from the queue.
+ * \param pvt a mbl_pvt structure
+ * \param buf a null terminated buffer containing an AT message
+ * \retval 0 success
+ * \retval -1 error
+ */
+static int handle_sms_prompt(struct mbl_pvt *pvt, char *buf)
+{
+	struct msg_queue_entry *msg;
+	if (!(msg = msg_queue_head(pvt))) {
+		ast_debug(1, "[%s] error, got sms prompt with no pending sms messages\n", pvt->id);
+		return 0;
+	}
+
+	if (msg->expected != AT_SMS_PROMPT) {
+		ast_debug(1, "[%s] error, got sms prompt but no pending sms messages\n", pvt->id);
+		return 0;
+	}
+
+	if (hfp_send_sms_text(pvt->hfp, msg->data)
+			|| msg_queue_push(pvt, AT_OK, AT_CMGS)) {
+		msg_queue_free_and_pop(pvt);
+		ast_debug(1, "[%s] error sending sms message\n", pvt->id);
+		return 0;
+	}
+
+	msg_queue_free_and_pop(pvt);
+	return 0;
+}
+
+
+static void *do_monitor_phone(void *data)
+{
+	struct mbl_pvt *pvt = (struct mbl_pvt *)data;
+	struct hfp_pvt *hfp = pvt->hfp;
+	char buf[256];
+	int t;
+	at_message_t at_msg;
+	struct msg_queue_entry *entry;
+
+	/* Note: At one point the initilization procedure was neatly contained
+	 * in the hfp_init() function, but that initilization method did not
+	 * work with non standard devices.  As a result, the initilization
+	 * procedure is not spread throughout the event handling loop.
+	 */
+
+	/* start initilization with the BRSF request */
+	ast_mutex_lock(&pvt->lock);
+	pvt->timeout = 10000;
+	if (hfp_send_brsf(hfp, &hfp_our_brsf)  || msg_queue_push(pvt, AT_BRSF, AT_BRSF)) {
+		ast_debug(1, "[%s] error sending BRSF\n", hfp->owner->id);
+		goto e_cleanup;
+	}
+	ast_mutex_unlock(&pvt->lock);
+
+	while (!check_unloading()) {
+		ast_mutex_lock(&pvt->lock);
+		t = pvt->timeout;
+		ast_mutex_unlock(&pvt->lock);
+
+		if (!rfcomm_wait(pvt->rfcomm_socket, &t)) {
+			ast_debug(1, "[%s] timeout waiting for rfcomm data, disconnecting\n", pvt->id);
+			ast_mutex_lock(&pvt->lock);
+			if (!hfp->initialized) {
+				if ((entry = msg_queue_head(pvt))) {
+					switch (entry->response_to) {
+					case AT_CIND_TEST:
+						if (pvt->blackberry)
+							ast_debug(1, "[%s] timeout during CIND test\n", hfp->owner->id);
+						else
+							ast_debug(1, "[%s] timeout during CIND test, try setting 'blackberry=yes'\n", hfp->owner->id);
+						break;
+					case AT_CMER:
+						if (pvt->blackberry)
+							ast_debug(1, "[%s] timeout after sending CMER, try setting 'blackberry=no'\n", hfp->owner->id);
+						else
+							ast_debug(1, "[%s] timeout after sending CMER\n", hfp->owner->id);
+						break;
+					default:
+						ast_debug(1, "[%s] timeout while waiting for %s in response to %s\n", pvt->id, at_msg2str(entry->expected), at_msg2str(entry->response_to));
+						break;
+					}
+				}
+			}
+			ast_mutex_unlock(&pvt->lock);
+			goto e_cleanup;
+		}
+
+		if ((at_msg = at_read_full(hfp->rsock, buf, sizeof(buf))) < 0) {
+			/* XXX gnu specific strerror_r is assummed here, this
+			 * is not really safe.  See the strerror(3) man page
+			 * for more info. */
+			ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, strerror_r(errno, buf, sizeof(buf)), errno);
+			break;
+		}
+
+		ast_debug(1, "[%s] %s\n", pvt->id, buf);
+
+		switch (at_msg) {
+		case AT_BRSF:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_brsf(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_CIND:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_cind(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_OK:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_ok(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_CMS_ERROR:
+		case AT_ERROR:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_error(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_RING:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_ring(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_CIEV:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_ciev(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_CLIP:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_clip(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_CMTI:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_cmti(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_CMGR:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_response_cmgr(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_SMS_PROMPT:
+			ast_mutex_lock(&pvt->lock);
+			if (handle_sms_prompt(pvt, buf)) {
+				ast_mutex_unlock(&pvt->lock);
+				goto e_cleanup;
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		case AT_UNKNOWN:
+			ast_debug(1, "[%s] ignoring unknown message: %s\n", pvt->id, buf);
+			break;
+		case AT_PARSE_ERROR:
+			ast_debug(1, "[%s] error parsing message\n", pvt->id);
+			goto e_cleanup;
+		case AT_READ_ERROR:
+			ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, strerror_r(errno, buf, sizeof(buf)), errno);
+			goto e_cleanup;
+		default:
+			break;
+		}
+	}
+
+e_cleanup:
+
+	if (!hfp->initialized)
+		ast_verb(3, "Error initializing Bluetooth device %s.\n", pvt->id);
+
+	ast_mutex_lock(&pvt->lock);
+	if (pvt->owner) {
+		ast_debug(1, "[%s] device disconnected, hanging up owner\n", pvt->id);
+		pvt->needchup = 0;
+		mbl_queue_hangup(pvt);
+	}
+
+	close(pvt->rfcomm_socket);
+	close(pvt->sco_socket);
+	pvt->sco_socket = -1;
+
+	msg_queue_flush(pvt);
+
+	pvt->connected = 0;
+	hfp->initialized = 0;
+
+	pvt->adapter->inuse = 0;
+	ast_mutex_unlock(&pvt->lock);
+
+	ast_verb(3, "Bluetooth Device %s has disconnected.\n", pvt->id);
+	manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Disconnect\r\nDevice: %s\r\n", pvt->id);
+
+	return NULL;
+}
+
+static int headset_send_ring(const void *data)
+{
+	struct mbl_pvt *pvt = (struct mbl_pvt *) data;
+	ast_mutex_lock(&pvt->lock);
+	if (!pvt->needring) {
+		ast_mutex_unlock(&pvt->lock);
+		return 0;
+	}
+	ast_mutex_unlock(&pvt->lock);
+
+	if (hsp_send_ring(pvt->rfcomm_socket)) {
+		ast_debug(1, "[%s] error sending RING\n", pvt->id);
+		return 0;
+	}
+	return 1;
+}
+
+static void *do_monitor_headset(void *data)
+{
+
+	struct mbl_pvt *pvt = (struct mbl_pvt *)data;
+	char buf[256];
+	int t;
+	at_message_t at_msg;
+	struct ast_channel *chan = NULL;
+
+	ast_verb(3, "Bluetooth Device %s initialised and ready.\n", pvt->id);
+
+	while (!check_unloading()) {
+
+		t = ast_sched_wait(pvt->sched);
+		if (t == -1) {
+			t = 6000;
+		}
+
+		ast_sched_runq(pvt->sched);
+
+		if (rfcomm_wait(pvt->rfcomm_socket, &t) == 0)
+			continue;
+
+		if ((at_msg = at_read_full(pvt->rfcomm_socket, buf, sizeof(buf))) < 0) {
+			if (strerror_r(errno, buf, sizeof(buf)))
+				ast_debug(1, "[%s] error reading from device\n", pvt->id);
+			else
+				ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, buf, errno);
+
+			goto e_cleanup;
+		}
+		ast_debug(1, "[%s] %s\n", pvt->id, buf);
+
+		switch (at_msg) {
+		case AT_VGS:
+		case AT_VGM:
+			/* XXX volume change requested, we will just
+			 * pretend to do something with it */
+			if (hsp_send_ok(pvt->rfcomm_socket)) {
+				ast_debug(1, "[%s] error sending AT message 'OK'\n", pvt->id);
+				goto e_cleanup;
+			}
+			break;
+		case AT_CKPD:
+			ast_mutex_lock(&pvt->lock);
+			if (pvt->outgoing) {
+				pvt->needring = 0;
+				hsp_send_ok(pvt->rfcomm_socket);
+				if (pvt->answered) {
+					/* we have an answered call up to the
+					 * HS, he wants to hangup */
+					mbl_queue_hangup(pvt);
+				} else {
+					/* we have an outgoing call to the HS,
+					 * he wants to answer */
+					if ((pvt->sco_socket = sco_connect(pvt->adapter->addr, pvt->addr)) == -1) {
+						ast_log(LOG_ERROR, "[%s] unable to create audio connection\n", pvt->id);
+						mbl_queue_hangup(pvt);
+						ast_mutex_unlock(&pvt->lock);
+						goto e_cleanup;
+					}
+
+					ast_channel_set_fd(pvt->owner, 0, pvt->sco_socket);
+
+					mbl_queue_control(pvt, AST_CONTROL_ANSWER);
+					pvt->answered = 1;
+
+					if (hsp_send_vgs(pvt->rfcomm_socket, 13) || hsp_send_vgm(pvt->rfcomm_socket, 13)) {
+						ast_debug(1, "[%s] error sending VGS/VGM\n", pvt->id);
+						mbl_queue_hangup(pvt);
+						ast_mutex_unlock(&pvt->lock);
+						goto e_cleanup;
+					}
+				}
+			} else if (pvt->incoming) {
+				/* we have an incoming call from the
+				 * HS, he wants to hang up */
+				mbl_queue_hangup(pvt);
+			} else {
+				/* no call is up, HS wants to dial */
+				hsp_send_ok(pvt->rfcomm_socket);
+
+				if ((pvt->sco_socket = sco_connect(pvt->adapter->addr, pvt->addr)) == -1) {
+					ast_log(LOG_ERROR, "[%s] unable to create audio connection\n", pvt->id);
+					ast_mutex_unlock(&pvt->lock);
+					goto e_cleanup;
+				}
+
+				pvt->incoming = 1;
+
+				if (!(chan = mbl_new(AST_STATE_UP, pvt, NULL, NULL))) {
+					ast_log(LOG_ERROR, "[%s] unable to allocate channel for incoming call\n", pvt->id);
+					ast_mutex_unlock(&pvt->lock);
+					goto e_cleanup;
+				}
+
+				ast_channel_set_fd(chan, 0, pvt->sco_socket);
+
+				ast_copy_string(chan->exten, "s", AST_MAX_EXTENSION);
+				if (ast_pbx_start(chan)) {
+					ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming call\n", pvt->id);
+					ast_hangup(chan);
+					ast_mutex_unlock(&pvt->lock);
+					goto e_cleanup;
+				}
+			}
+			ast_mutex_unlock(&pvt->lock);
+			break;
+		default:
+			ast_debug(1, "[%s] received unknown AT command: %s (%s)\n", pvt->id, buf, at_msg2str(at_msg));
+			if (hsp_send_error(pvt->rfcomm_socket)) {
+				ast_debug(1, "[%s] error sending AT message 'ERROR'\n", pvt->id);
+				goto e_cleanup;
+			}
+			break;
+		}
+	}
+
+e_cleanup:
+	ast_mutex_lock(&pvt->lock);
+	if (pvt->owner) {
+		ast_debug(1, "[%s] device disconnected, hanging up owner\n", pvt->id);
+		mbl_queue_hangup(pvt);
+	}
+
+
+	close(pvt->rfcomm_socket);
+	close(pvt->sco_socket);
+	pvt->sco_socket = -1;
+
+	pvt->connected = 0;
+
+	pvt->needring = 0;
+	pvt->outgoing = 0;
+	pvt->incoming = 0;
+
+	pvt->adapter->inuse = 0;
+	ast_mutex_unlock(&pvt->lock);
+
+	manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Disconnect\r\nDevice: %s\r\n", pvt->id);
+	ast_verb(3, "Bluetooth Device %s has disconnected\n", pvt->id);
+
+	return NULL;
+
+}
+
+static int start_monitor(struct mbl_pvt *pvt)
+{
+
+	if (pvt->type == MBL_TYPE_PHONE) {
+		pvt->hfp->rsock = pvt->rfcomm_socket;
+
+		if (ast_pthread_create_background(&pvt->monitor_thread, NULL, do_monitor_phone, pvt) < 0) {
+			pvt->monitor_thread = AST_PTHREADT_NULL;
+			return 0;
+		}
+	} else {
+		if (ast_pthread_create_background(&pvt->monitor_thread, NULL, do_monitor_headset, pvt) < 0) {
+			pvt->monitor_thread = AST_PTHREADT_NULL;
+			return 0;
+		}
+	}
+
+	return 1;
+
+}
+
+static void *do_discovery(void *data)
+{
+
+	struct adapter_pvt *adapter;
+	struct mbl_pvt *pvt;
+
+	while (!check_unloading()) {
+		AST_RWLIST_RDLOCK(&adapters);
+		AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
+			if (!adapter->inuse) {
+				AST_RWLIST_RDLOCK(&devices);
+				AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
+					ast_mutex_lock(&pvt->lock);
+					if (!adapter->inuse && !pvt->connected && !strcmp(adapter->id, pvt->adapter->id)) {
+						if ((pvt->rfcomm_socket = rfcomm_connect(adapter->addr, pvt->addr, pvt->rfcomm_port)) > -1) {
+							if (start_monitor(pvt)) {
+								pvt->connected = 1;
+								adapter->inuse = 1;
+								manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Connect\r\nDevice: %s\r\n", pvt->id);
+								ast_verb(3, "Bluetooth Device %s has connected, initilizing...\n", pvt->id);
+							}
+						}
+					}
+					ast_mutex_unlock(&pvt->lock);
+				}
+				AST_RWLIST_UNLOCK(&devices);
+			}
+		}
+		AST_RWLIST_UNLOCK(&adapters);
+
+
+		/* Go to sleep (only if we are not unloading) */
+		if (!check_unloading())
+			sleep(discovery_interval);
+	}
+
+	return NULL;
+}
+
+/*!
+ * \brief Service new and existing SCO connections.
+ * This thread accepts new sco connections and handles audio data.  There is
+ * one do_sco_listen thread for each adapter.
+ */
+static void *do_sco_listen(void *data)
+{
+	struct adapter_pvt *adapter = (struct adapter_pvt *) data;
+	int res;
+
+	while (!check_unloading()) {
+		/* check for new sco connections */
+		if ((res = ast_io_wait(adapter->accept_io, 0)) == -1) {
+			/* handle errors */
+			ast_log(LOG_ERROR, "ast_io_wait() failed for adapter %s\n", adapter->id);
+			break;
+		}
+
+		/* handle audio data */
+		if ((res = ast_io_wait(adapter->io, 1)) == -1) {
+			ast_log(LOG_ERROR, "ast_io_wait() failed for audio on adapter %s\n", adapter->id);
+			break;
+		}
+	}
+
+	return NULL;
+}
+
+/*
+
+	Module
+
+*/
+
+/*!
+ * \brief Load an adapter from the configuration file.
+ * \param cfg the config to load the adapter from
+ * \param cat the adapter to load
+ *
+ * This function loads the given adapter and starts the sco listener thread for
+ * that adapter.
+ *
+ * \return NULL on error, a pointer to the adapter that was loaded on success
+ */
+static struct adapter_pvt *mbl_load_adapter(struct ast_config *cfg, const char *cat)
+{
+	const char *id, *address;
+	struct adapter_pvt *adapter;
+	struct ast_variable *v;
+	struct hci_dev_req dr;
+	uint16_t vs;
+
+	id = ast_variable_retrieve(cfg, cat, "id");
+	address = ast_variable_retrieve(cfg, cat, "address");
+
+	if (ast_strlen_zero(id) || ast_strlen_zero(address)) {
+		ast_log(LOG_ERROR, "Skipping adapter. Missing id or address settings.\n");
+		goto e_return;
+	}
+
+	ast_debug(1, "Reading configuration for adapter %s %s.\n", id, address);
+
+	if (!(adapter = ast_calloc(1, sizeof(*adapter)))) {
+		ast_log(LOG_ERROR, "Skipping adapter %s. Error allocating memory.\n", id);
+		goto e_return;
+	}
+
+	ast_copy_string(adapter->id, id, sizeof(adapter->id));
+	str2ba(address, &adapter->addr);
+
+	/* attempt to connect to the adapter */
+	adapter->dev_id = hci_devid(address);
+	adapter->hci_socket = hci_open_dev(adapter->dev_id);
+	if (adapter->dev_id < 0 || adapter->hci_socket < 0) {
+		ast_log(LOG_ERROR, "Skipping adapter %s. Unable to communicate with adapter.\n", adapter->id);
+		goto e_free_adapter;
+	}
+
+	/* check voice setting */
+	hci_read_voice_setting(adapter->hci_socket, &vs, 1000);
+	vs = htobs(vs);
+	if (vs != 0x0060) {
+		ast_log(LOG_ERROR, "Skipping adapter %s. Voice setting must be 0x0060 - see 'man hciconfig' for details.\n", adapter->id);
+		goto e_hci_close_dev;
+	}
+
+	for (v = ast_variable_browse(cfg, cat); v; v = v->next) {
+		if (!strcasecmp(v->name, "forcemaster")) {
+			if (ast_true(v->value)) {
+				dr.dev_id = adapter->dev_id;
+				if (hci_strtolm("master", &dr.dev_opt)) {
+					if (ioctl(adapter->hci_socket, HCISETLINKMODE, (unsigned long) &dr) < 0) {
+						ast_log(LOG_WARNING, "Unable to set adapter %s link mode to MASTER. Ignoring 'forcemaster' option.\n", adapter->id);
+					}
+				}
+			}
+		} else if (!strcasecmp(v->name, "alignmentdetection")) {
+			adapter->alignment_detection = ast_true(v->value);
+		}
+	}
+
+	/* create io contexts */
+	if (!(adapter->accept_io = io_context_create())) {
+		ast_log(LOG_ERROR, "Unable to create I/O context for audio connection listener\n");
+		goto e_hci_close_dev;
+	}
+
+	if (!(adapter->io = io_context_create())) {
+		ast_log(LOG_ERROR, "Unable to create I/O context for audio connections\n");
+		goto e_destroy_accept_io;
+	}
+
+	/* bind the sco listener socket */
+	if (sco_bind(adapter) < 0) {
+		ast_log(LOG_ERROR, "Skipping adapter %s. Error binding audio connection listerner socket.\n", adapter->id);
+		goto e_destroy_io;
+	}
+
+	/* add the socket to the io context */
+	if (!(adapter->sco_id = ast_io_add(adapter->accept_io, adapter->sco_socket, sco_accept, AST_IO_IN, adapter))) {
+		ast_log(LOG_ERROR, "Skipping adapter %s. Error adding listener socket to I/O context.\n", adapter->id);
+		goto e_close_sco;
+	}
+
+	/* start the sco listener for this adapter */
+	if (ast_pthread_create_background(&adapter->sco_listener_thread, NULL, do_sco_listen, adapter)) {
+		ast_log(LOG_ERROR, "Skipping adapter %s. Error creating audio connection listerner thread.\n", adapter->id);
+		goto e_remove_sco;
+	}
+
+	/* add the adapter to our global list */
+	AST_RWLIST_WRLOCK(&adapters);
+	AST_RWLIST_INSERT_HEAD(&adapters, adapter, entry);
+	AST_RWLIST_UNLOCK(&adapters);
+	ast_debug(1, "Loaded adapter %s %s.\n", adapter->id, address);
+
+	return adapter;
+
+e_remove_sco:
+	ast_io_remove(adapter->accept_io, adapter->sco_id);
+e_close_sco:
+	close(adapter->sco_socket);
+e_destroy_io:
+	io_context_destroy(adapter->io);
+e_destroy_accept_io:
+	io_context_destroy(adapter->accept_io);
+e_hci_close_dev:
+	hci_close_dev(adapter->hci_socket);
+e_free_adapter:
+	ast_free(adapter);
+e_return:
+	return NULL;
+}
+
+/*!
+ * \brief Load a device from the configuration file.
+ * \param cfg the config to load the device from
+ * \param cat the device to load
+ * \return NULL on error, a pointer to the device that was loaded on success
+ */
+static struct mbl_pvt *mbl_load_device(struct ast_config *cfg, const char *cat)
+{
+	struct mbl_pvt *pvt;
+	struct adapter_pvt *adapter;
+	struct ast_variable *v;
+	const char *address, *adapter_str, *port;
+	ast_debug(1, "Reading configuration for device %s.\n", cat);
+
+	adapter_str = ast_variable_retrieve(cfg, cat, "adapter");
+	if(ast_strlen_zero(adapter_str)) {
+		ast_log(LOG_ERROR, "Skipping device %s. No adapter specified.\n", cat);
+		goto e_return;
+	}
+
+	/* find the adapter */
+	AST_RWLIST_RDLOCK(&adapters);
+	AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
+		if (!strcmp(adapter->id, adapter_str))
+			break;
+	}
+	AST_RWLIST_UNLOCK(&adapters);
+	if (!adapter) {
+		ast_log(LOG_ERROR, "Skiping device %s. Unknown adapter '%s' specified.\n", cat, adapter_str);
+		goto e_return;
+	}
+
+	address = ast_variable_retrieve(cfg, cat, "address");
+	port = ast_variable_retrieve(cfg, cat, "port");
+	if (ast_strlen_zero(port) || ast_strlen_zero(address)) {
+		ast_log(LOG_ERROR, "Skipping device %s. Missing required port or address setting.\n", cat);
+		goto e_return;
+	}
+
+	/* create and initialize our pvt structure */
+	if (!(pvt = ast_calloc(1, sizeof(*pvt)))) {
+		ast_log(LOG_ERROR, "Skipping device %s. Error allocating memory.\n", cat);
+		goto e_return;
+	}
+
+	ast_mutex_init(&pvt->lock);
+	AST_LIST_HEAD_INIT_NOLOCK(&pvt->msg_queue);
+
+	/* set some defaults */
+
+	pvt->type = MBL_TYPE_PHONE;
+	ast_copy_string(pvt->context, "default", sizeof(pvt->context));
+
+	/* populate the pvt structure */
+	pvt->adapter = adapter;
+	ast_copy_string(pvt->id, cat, sizeof(pvt->id));
+	str2ba(address, &pvt->addr);
+	pvt->timeout = -1;
+	pvt->rfcomm_socket = -1;
+	pvt->rfcomm_port = atoi(port);
+	pvt->sco_socket = -1;
+	pvt->monitor_thread = AST_PTHREADT_NULL;
+	pvt->ring_sched_id = -1;
+
+	/* setup the smoother */
+	if (!(pvt->smoother = ast_smoother_new(DEVICE_FRAME_SIZE))) {
+		ast_log(LOG_ERROR, "Skipping device %s. Error setting up frame smoother.\n", cat);
+		goto e_free_pvt;
+	}
+
+	/* setup the dsp */
+	if (!(pvt->dsp = ast_dsp_new())) {
+		ast_log(LOG_ERROR, "Skipping device %s. Error setting up dsp for dtmf detection.\n", cat);
+		goto e_free_smoother;
+	}
+
+	/* setup the scheduler */
+	if (!(pvt->sched = sched_context_create())) {
+		ast_log(LOG_ERROR, "Unable to create scheduler context for headset device\n");
+		goto e_free_dsp;
+	}
+
+	ast_dsp_set_features(pvt->dsp, DSP_FEATURE_DIGIT_DETECT);
+	ast_dsp_set_digitmode(pvt->dsp, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
+
+	for (v = ast_variable_browse(cfg, cat); v; v = v->next) {
+		if (!strcasecmp(v->name, "type")) {
+			if (!strcasecmp(v->value, "headset"))
+				pvt->type = MBL_TYPE_HEADSET;
+			else
+				pvt->type = MBL_TYPE_PHONE;
+		} else if (!strcasecmp(v->name, "context")) {
+			ast_copy_string(pvt->context, v->value, sizeof(pvt->context));
+		} else if (!strcasecmp(v->name, "group")) {
+			/* group is set to 0 if invalid */
+			pvt->group = atoi(v->value);
+		} else if (!strcasecmp(v->name, "nocallsetup")) {
+			pvt->no_callsetup = ast_true(v->value);
+
+			if (pvt->no_callsetup)
+				ast_debug(1, "Setting nocallsetup mode for device %s.\n", pvt->id);
+		} else if (!strcasecmp(v->name, "blackberry")) {
+			pvt->blackberry = ast_true(v->value);
+		}
+	}
+
+	if (pvt->type == MBL_TYPE_PHONE) {
+		if (!(pvt->hfp = ast_calloc(1, sizeof(*pvt->hfp)))) {
+			ast_log(LOG_ERROR, "Skipping device %s. Error allocating memory.\n", pvt->id);
+			goto e_free_sched;
+		}
+
+		pvt->hfp->owner = pvt;
+		pvt->hfp->rport = pvt->rfcomm_port;
+		pvt->hfp->nocallsetup = pvt->no_callsetup;
+	}
+
+	AST_RWLIST_WRLOCK(&devices);
+	AST_RWLIST_INSERT_HEAD(&devices, pvt, entry);
+	AST_RWLIST_UNLOCK(&devices);
+	ast_debug(1, "Loaded device %s.\n", pvt->id);
+
+	return pvt;
+
+e_free_sched:
+	sched_context_destroy(pvt->sched);
+e_free_dsp:
+	ast_dsp_free(pvt->dsp);
+e_free_smoother:
+	ast_smoother_free(pvt->smoother);
+e_free_pvt:
+	ast_free(pvt);
+e_return:
+	return NULL;
+}
+
+static int mbl_load_config(void)
+{
+	struct ast_config *cfg;
+	const char *cat;
+	struct ast_variable *v;
+	struct ast_flags config_flags = { 0 };
+
+	cfg = ast_config_load(MBL_CONFIG, config_flags);
+	if (!cfg)
+		return -1;
+
+	/* parse [general] section */
+	for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
+		if (!strcasecmp(v->name, "interval")) {
+			if (!sscanf(v->value, "%d", &discovery_interval)) {
+				ast_log(LOG_NOTICE, "error parsing 'interval' in general section, using default value\n");
+			}
+		}
+	}
+
+	/* load adapters */
+	for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) {
+		if (!strcasecmp(cat, "adapter")) {
+			mbl_load_adapter(cfg, cat);
+		}
+	}
+
+	if (AST_RWLIST_EMPTY(&adapters)) {
+		ast_log(LOG_ERROR,
+			"***********************************************************************\n"
+			"No adapters could be loaded from the configuration file.\n"
+			"Please review mobile.conf. See sample for details.\n"
+			"***********************************************************************\n"
+		       );
+		ast_config_destroy(cfg);
+		return -1;
+	}
+
+	/* now load devices */
+	for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) {
+		if (strcasecmp(cat, "general") && strcasecmp(cat, "adapter")) {
+			mbl_load_device(cfg, cat);
+		}
+	}
+
+	ast_config_destroy(cfg);
+
+	return 0;
+}
+
+/*!
+ * \brief Check if the module is unloading.
+ * \retval 0 not unloading
+ * \retval 1 unloading
+ */
+static inline int check_unloading()
+{
+	int res;
+	ast_mutex_lock(&unload_mutex);
+	res = unloading_flag;
+	ast_mutex_unlock(&unload_mutex);
+
+	return res;
+}
+
+/*!
+ * \brief Set the unloading flag.
+ */
+static inline void set_unloading()
+{
+	ast_mutex_lock(&unload_mutex);
+	unloading_flag = 1;
+	ast_mutex_unlock(&unload_mutex);
+}
+
+static int unload_module(void)
+{
+	struct mbl_pvt *pvt;
+	struct adapter_pvt *adapter;
+
+	/* First, take us out of the channel loop */
+	ast_channel_unregister(&mbl_tech);
+
+	/* Unregister the CLI & APP */
+	ast_cli_unregister_multiple(mbl_cli, sizeof(mbl_cli) / sizeof(mbl_cli[0]));
+	ast_unregister_application(app_mblstatus);
+	ast_unregister_application(app_mblsendsms);
+
+	/* signal everyone we are unloading */
+	set_unloading();
+
+	/* Kill the discovery thread */
+	if (discovery_thread != AST_PTHREADT_NULL) {
+		pthread_kill(discovery_thread, SIGURG);
+		pthread_join(discovery_thread, NULL);
+	}
+
+	/* stop the sco listener threads */
+	AST_RWLIST_WRLOCK(&adapters);
+	AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
+		pthread_kill(adapter->sco_listener_thread, SIGURG);
+		pthread_join(adapter->sco_listener_thread, NULL);
+	}
+	AST_RWLIST_UNLOCK(&adapters);
+
+	/* Destroy the device list */
+	AST_RWLIST_WRLOCK(&devices);
+	while ((pvt = AST_RWLIST_REMOVE_HEAD(&devices, entry))) {
+		if (pvt->monitor_thread != AST_PTHREADT_NULL) {
+			pthread_kill(pvt->monitor_thread, SIGURG);
+			pthread_join(pvt->monitor_thread, NULL);
+		}
+
+		close(pvt->sco_socket);
+		close(pvt->rfcomm_socket);
+
+		msg_queue_flush(pvt);
+
+		if (pvt->hfp) {
+			ast_free(pvt->hfp);
+		}
+
+		ast_smoother_free(pvt->smoother);
+		ast_dsp_free(pvt->dsp);
+		sched_context_destroy(pvt->sched);
+		ast_free(pvt);
+	}
+	AST_RWLIST_UNLOCK(&devices);
+
+	/* Destroy the adapter list */
+	AST_RWLIST_WRLOCK(&adapters);
+	while ((adapter = AST_RWLIST_REMOVE_HEAD(&adapters, entry))) {
+		close(adapter->sco_socket);
+		io_context_destroy(adapter->io);
+		io_context_destroy(adapter->accept_io);
+		hci_close_dev(adapter->hci_socket);
+		ast_free(adapter);
+	}
+	AST_RWLIST_UNLOCK(&adapters);
+
+	if (sdp_session)
+		sdp_close(sdp_session);
+
+	return 0;
+}
+
+static int load_module(void)
+{
+
+	int dev_id, s;
+
+	/* Check if we have Bluetooth, no point loading otherwise... */
+	dev_id = hci_get_route(NULL);
+	s = hci_open_dev(dev_id);
+	if (dev_id < 0 || s < 0) {
+		ast_log(LOG_ERROR, "No Bluetooth devices found. Not loading module.\n");
+		return AST_MODULE_LOAD_DECLINE;
+	}
+
+	hci_close_dev(s);
+
+	if (mbl_load_config()) {
+		ast_log(LOG_ERROR, "Errors reading config file %s. Not loading module.\n", MBL_CONFIG);
+		return AST_MODULE_LOAD_DECLINE;
+	}
+
+	sdp_session = sdp_register();
+
+	/* Spin the discovery thread */
+	if (ast_pthread_create_background(&discovery_thread, NULL, do_discovery, NULL) < 0) {
+		ast_log(LOG_ERROR, "Unable to create discovery thread.\n");
+		goto e_cleanup;
+	}
+
+	/* register our channel type */
+	if (ast_channel_register(&mbl_tech)) {
+		ast_log(LOG_ERROR, "Unable to register channel class %s\n", "Mobile");
+		goto e_cleanup;
+	}
+
+	ast_cli_register_multiple(mbl_cli, sizeof(mbl_cli) / sizeof(mbl_cli[0]));
+	ast_register_application(app_mblstatus, mbl_status_exec, mblstatus_synopsis, mblstatus_desc);
+	ast_register_application(app_mblsendsms, mbl_sendsms_exec, mblsendsms_synopsis, mblsendsms_desc);
+
+	return AST_MODULE_LOAD_SUCCESS;
+
+e_cleanup:
+	if (sdp_session)
+		sdp_close(sdp_session);
+
+	return AST_MODULE_LOAD_FAILURE;
+}
+
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Bluetooth Mobile Device Channel Driver",
+		.load = load_module,
+		.unload = unload_module,
+);
diff --git a/addons/chan_ooh323.c b/addons/chan_ooh323.c
new file mode 100644
index 000000000..70c0f0209
--- /dev/null
+++ b/addons/chan_ooh323.c
@@ -0,0 +1,3162 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+
+#include "chan_ooh323.h"
+
+/*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
+ ***/
+
+/* Defaults */
+#define DEFAULT_CONTEXT "default"
+#define DEFAULT_H323ID "Asterisk PBX"
+#define DEFAULT_LOGFILE "/var/log/asterisk/h323_log"
+#define DEFAULT_H323ACCNT "ast_h323"
+
+/* Flags */
+#define H323_SILENCESUPPRESSION (1<<0)
+#define H323_GKROUTED           (1<<1)
+#define H323_TUNNELING          (1<<2)
+#define H323_FASTSTART          (1<<3)
+#define H323_OUTGOING           (1<<4)
+#define H323_ALREADYGONE        (1<<5)
+#define H323_NEEDDESTROY        (1<<6)
+#define H323_DISABLEGK          (1<<7)
+
+/* Channel description */
+static const char type[] = "OOH323";
+static const char tdesc[] = "Objective Systems H323 Channel Driver";
+static const char config[] = "ooh323.conf";
+
+
+/* Channel Definition */
+static struct ast_channel *ooh323_request(const char *type, int format, 
+                                        void *data, int *cause);
+static int ooh323_digit_begin(struct ast_channel *ast, char digit);
+static int ooh323_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
+static int ooh323_call(struct ast_channel *ast, char *dest, int timeout);
+static int ooh323_hangup(struct ast_channel *ast);
+static int ooh323_answer(struct ast_channel *ast);
+static struct ast_frame *ooh323_read(struct ast_channel *ast);
+static int ooh323_write(struct ast_channel *ast, struct ast_frame *f);
+static int ooh323_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
+static int ooh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
+
+static enum ast_rtp_get_result ooh323_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp);
+static enum ast_rtp_get_result ooh323_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp);
+static int ooh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, 
+                             struct ast_rtp *vrtp, struct ast_rtp *trtp, int codecs, int nat_active);
+
+static void print_codec_to_cli(int fd, struct ast_codec_pref *pref);
+
+#if 0
+static void ast_ooh323c_exit();
+#endif
+
+static const struct ast_channel_tech ooh323_tech = {
+	.type = type,
+	.description = tdesc,
+	.capabilities = -1,
+	.requester = ooh323_request,
+	.send_digit_begin = ooh323_digit_begin,
+	.send_digit_end = ooh323_digit_end,
+	.call = ooh323_call,
+	.hangup = ooh323_hangup,
+	.answer = ooh323_answer,
+	.read = ooh323_read,
+	.write = ooh323_write,
+	.exception = ooh323_read,
+	.indicate = ooh323_indicate,
+	.fixup = ooh323_fixup,
+	.send_html = 0,
+	.bridge = ast_rtp_bridge,
+};
+
+static struct ast_rtp_protocol ooh323_rtp = {
+	.type = type,
+	.get_rtp_info = ooh323_get_rtp_peer,
+	.get_vrtp_info = ooh323_get_vrtp_peer,
+	.set_rtp_peer = ooh323_set_rtp_peer
+};
+
+/* H.323 channel private structure */
+static struct ooh323_pvt {
+	ast_mutex_t lock;		/* Channel private lock */
+	struct ast_rtp *rtp;
+	struct ast_rtp *vrtp; /* Placeholder for now */
+	struct ast_channel *owner;	/* Master Channel */
+	time_t lastrtptx;
+	time_t lastrtprx;
+	unsigned int flags;
+	unsigned int call_reference;
+	char *callToken;
+	char *username;
+	char *host;
+	char *callerid_name;
+	char *callerid_num;
+	char caller_h323id[AST_MAX_EXTENSION];
+	char caller_dialedDigits[AST_MAX_EXTENSION];
+	char caller_email[AST_MAX_EXTENSION];
+	char caller_url[256];
+	char callee_h323id[AST_MAX_EXTENSION];
+	char callee_dialedDigits[AST_MAX_EXTENSION];
+	char callee_email[AST_MAX_EXTENSION];
+	char callee_url[AST_MAX_EXTENSION];
+ 
+	int port;
+	int readformat;   /* negotiated read format */
+	int writeformat;  /* negotiated write format */
+	int capability;
+	struct ast_codec_pref prefs;
+	int dtmfmode;
+	char exten[AST_MAX_EXTENSION];	/* Requested extension */
+	char context[AST_MAX_EXTENSION];	/* Context where to start */
+	char accountcode[256];	/* Account code */
+	int nat;
+	int amaflags;
+	struct ast_dsp *vad;
+	struct ooh323_pvt *next;	/* Next entity */
+} *iflist = NULL;
+
+/* Protect the channel/interface list (ooh323_pvt) */
+AST_MUTEX_DEFINE_STATIC(iflock);
+
+/* Profile of H.323 user registered with PBX*/
+struct ooh323_user{
+	ast_mutex_t lock;
+	char        name[256];
+	char        context[AST_MAX_EXTENSION];
+	int         incominglimit;
+	unsigned    inUse;
+	char        accountcode[20];
+	int         amaflags;
+	int         capability;
+	struct ast_codec_pref prefs;
+	int         dtmfmode;
+	int         rtptimeout;
+	int         mUseIP;        /* Use IP address or H323-ID to search user */
+	char        mIP[20];
+	struct ooh323_user *next;
+};
+
+/* Profile of valid asterisk peers */
+struct ooh323_peer{
+	ast_mutex_t lock;
+	char        name[256];
+	unsigned    outgoinglimit;
+	unsigned    outUse;
+	int         capability;
+	struct ast_codec_pref prefs;
+	char        accountcode[20];
+	int         amaflags;
+	int         dtmfmode;
+	int         mFriend;    /* indicates defined as friend */
+	char        ip[20];
+	int         port;
+	char        *h323id;    /* H323-ID alias, which asterisk will register with gk to reach this peer*/
+	char        *email;     /* Email alias, which asterisk will register with gk to reach this peer*/
+	char        *url;       /* url alias, which asterisk will register with gk to reach this peer*/
+	char        *e164;      /* e164 alias, which asterisk will register with gk to reach this peer*/
+	int         rtptimeout;
+	struct ooh323_peer *next;
+};
+
+
+/* List of H.323 users known to PBX */
+static struct ast_user_list {
+	struct ooh323_user *users;
+	ast_mutex_t lock;
+} userl;
+
+static struct ast_peer_list {
+	struct ooh323_peer *peers;
+	ast_mutex_t lock;
+} peerl;
+
+/* Mutex to protect H.323 reload process */
+static int h323_reloading = 0;
+AST_MUTEX_DEFINE_STATIC(h323_reload_lock);
+
+/* Mutex to protect usage counter */
+static int usecnt = 0;
+AST_MUTEX_DEFINE_STATIC(usecnt_lock);
+
+AST_MUTEX_DEFINE_STATIC(ooh323c_cmd_lock);
+
+/* stack callbacks */
+int onAlerting(ooCallData *call);
+int onNewCallCreated(ooCallData *call);
+int onCallEstablished(ooCallData *call);
+int onCallCleared(ooCallData *call);
+
+static char gLogFile[256] = DEFAULT_LOGFILE;
+static int  gPort = 1720;
+static char gIP[20];
+static char gCallerID[AST_MAX_EXTENSION] = DEFAULT_H323ID;
+static struct ooAliases *gAliasList;
+static int  gCapability = AST_FORMAT_ULAW;
+static struct ast_codec_pref gPrefs;
+static int  gDTMFMode = H323_DTMF_RFC2833;
+static char gGatekeeper[100];
+static enum RasGatekeeperMode gRasGkMode = RasNoGatekeeper;
+
+static int  gIsGateway = 0;
+static int  gFastStart = 1;
+static int  gTunneling = 1;
+static int  gMediaWaitForConnect = 0;
+static int  gTOS = 0;
+static int  gRTPTimeout = 60;
+static char gAccountcode[80] = DEFAULT_H323ACCNT;
+static int  gAMAFLAGS;
+static char gContext[AST_MAX_EXTENSION] = DEFAULT_CONTEXT;
+static int  gIncomingLimit = 4;
+static int  gOutgoingLimit = 4;
+OOBOOL gH323Debug = FALSE;
+
+static struct ooh323_config
+{
+   int  mTCPPortStart;
+   int  mTCPPortEnd;
+} ooconfig;
+
+/** Asterisk RTP stuff*/
+static struct sched_context *sched;
+static struct io_context *io;
+
+/* Protect the monitoring thread, so only one process can kill or start it, 
+   and not when it's doing something critical. */
+AST_MUTEX_DEFINE_STATIC(monlock);
+
+
+/* This is the thread for the monitor which checks for input on the channels
+   which are not currently in use.  */
+static pthread_t monitor_thread = AST_PTHREADT_NULL;
+
+
+static struct ast_channel *ooh323_new(struct ooh323_pvt *i, int state,
+                                             const char *host) 
+{
+	struct ast_channel *ch = NULL;
+	int fmt;
+	if (gH323Debug)
+		ast_verbose("---   ooh323_new - %s\n", host);
+
+
+	/* Don't hold a h323 pvt lock while we allocate a channel */
+	ast_mutex_unlock(&i->lock);
+	ch = ast_channel_alloc(1, state, i->callerid_num, i->callerid_name, i->accountcode, i->exten, i->context, i->amaflags, "OOH323/%s-%08x", host, (unsigned int)(unsigned long) i);
+	ast_mutex_lock(&i->lock);
+
+	if (ch) {
+		ast_channel_lock(ch);
+		ch->tech = &ooh323_tech;
+
+		ch->nativeformats = i->capability;
+
+		fmt = ast_best_codec(ch->nativeformats);
+
+		ch->fds[0] = ast_rtp_fd(i->rtp);
+		ch->fds[1] = ast_rtcp_fd(i->rtp);
+
+		if (state == AST_STATE_RING)
+			ch->rings = 1;
+
+		ch->adsicpe = AST_ADSI_UNAVAILABLE;
+		ch->writeformat = fmt;
+		ch->rawwriteformat = fmt;
+		ch->readformat = fmt;
+		ch->rawreadformat = fmt;
+		ch->tech_pvt = i;
+		i->owner = ch;
+
+		/* Allocate dsp for in-band DTMF support */
+		if (i->dtmfmode & H323_DTMF_INBAND) {
+			i->vad = ast_dsp_new();
+			ast_dsp_set_features(i->vad, DSP_FEATURE_DIGIT_DETECT);
+		}
+
+		ast_mutex_lock(&usecnt_lock);
+		usecnt++;
+		ast_mutex_unlock(&usecnt_lock);
+
+		/* Notify the module monitors that use count for resource has changed*/
+		ast_update_use_count();
+
+		ast_copy_string(ch->context, i->context, sizeof(ch->context));
+		ast_copy_string(ch->exten, i->exten, sizeof(ch->exten));
+
+		ch->priority = 1;
+		if (i->callerid_name) {
+			ch->cid.cid_name = strdup(i->callerid_name);
+		}
+		if (i->callerid_num) {
+
+			ch->cid.cid_num = strdup(i->callerid_num);
+		}
+
+		if (!ast_test_flag(i, H323_OUTGOING)) {
+		
+			if (!ast_strlen_zero(i->caller_h323id)) {
+				pbx_builtin_setvar_helper(ch, "_CALLER_H323ID", i->caller_h323id);
+
+			}
+			if (!ast_strlen_zero(i->caller_dialedDigits)) {
+				pbx_builtin_setvar_helper(ch, "_CALLER_H323DIALEDDIGITS", 
+				i->caller_dialedDigits);
+			}
+			if (!ast_strlen_zero(i->caller_email)) {
+				pbx_builtin_setvar_helper(ch, "_CALLER_H323EMAIL", 
+				i->caller_email);
+			}
+			if (!ast_strlen_zero(i->caller_url)) {
+				pbx_builtin_setvar_helper(ch, "_CALLER_H323URL", i->caller_url);
+			}
+		}
+
+		if (!ast_strlen_zero(i->accountcode))
+			ast_string_field_set(ch, accountcode, i->accountcode);
+		
+		if (i->amaflags)
+			ch->amaflags = i->amaflags;
+
+		ast_setstate(ch, state);
+		if (state != AST_STATE_DOWN) {
+			if (ast_pbx_start(ch)) {
+				ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ch->name);
+				ast_channel_unlock(ch);
+				ast_hangup(ch);
+				ch = NULL;
+			}
+		}
+	} else
+		ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
+
+
+	if (ch)
+		ast_channel_unlock(ch);
+
+	if (gH323Debug)
+		ast_verbose("+++   h323_new\n");
+
+	return ch;
+}
+
+
+
+static struct ooh323_pvt *ooh323_alloc(int callref, char *callToken) 
+{
+	struct ooh323_pvt *pvt = NULL;
+	struct in_addr ipAddr;
+	if (gH323Debug)
+		ast_verbose("---   ooh323_alloc\n");
+
+	if (!(pvt = ast_calloc(1, sizeof(*pvt)))) {
+		ast_log(LOG_ERROR, "Couldn't allocate private ooh323 structure\n");
+		return NULL;
+	}
+
+	ast_mutex_init(&pvt->lock);
+	ast_mutex_lock(&pvt->lock);
+
+	if (!inet_aton(gIP, &ipAddr)) {
+		ast_log(LOG_ERROR, "Invalid OOH323 driver ip address\n");
+		ast_mutex_unlock(&pvt->lock);
+		ast_mutex_destroy(&pvt->lock);
+		free(pvt);
+		return NULL;
+	}
+
+	if (!(pvt->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, ipAddr))) {
+		ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", 
+				  strerror(errno));
+		ast_mutex_unlock(&pvt->lock);
+		ast_mutex_destroy(&pvt->lock);
+		free(pvt);
+		return NULL;
+	}
+ 
+	ast_rtp_setqos(pvt->rtp, gTOS, 0, "ooh323");
+
+	pvt->call_reference = callref;
+	if (callToken)
+		pvt->callToken = strdup(callToken);
+
+	/* whether to use gk for this call */
+	if (gRasGkMode == RasNoGatekeeper)
+		OO_SETFLAG(pvt->flags, H323_DISABLEGK);
+
+	pvt->dtmfmode = gDTMFMode;
+	ast_copy_string(pvt->context, gContext, sizeof(pvt->context));
+	ast_copy_string(pvt->accountcode, gAccountcode, sizeof(pvt->accountcode));
+	pvt->amaflags = gAMAFLAGS;
+	pvt->capability = gCapability;
+	memcpy(&pvt->prefs, &gPrefs, sizeof(pvt->prefs));
+
+	ast_mutex_unlock(&pvt->lock); 
+	/* Add to interface list */
+	ast_mutex_lock(&iflock);
+	pvt->next = iflist;
+	iflist = pvt;
+	ast_mutex_unlock(&iflock);
+
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_alloc\n");
+
+	return pvt;
+}
+
+
+/*
+	Possible data values - peername, exten/peername, exten@ip
+ */
+static struct ast_channel *ooh323_request(const char *type, int format, 
+													 void *data, int *cause)
+{
+	struct ast_channel *chan = NULL;
+	struct ooh323_pvt *p = NULL;
+	struct ooh323_peer *peer = NULL;
+	char *dest = NULL; 
+	char *ext = NULL;
+	char tmp[256];
+	char formats[512];
+	int oldformat;
+	int port = 0;
+
+	if (gH323Debug)
+		ast_verbose("---   ooh323_request - data %s format %s\n", (char*)data,  
+										ast_getformatname_multiple(formats,512,format));
+
+	oldformat = format;
+	format &= AST_FORMAT_AUDIO_MASK;
+	if (!format) {
+		ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format "
+								  "'%d'\n", format);
+		return NULL;
+	}
+
+	p = ooh323_alloc(0,0); /* Initial callRef is zero */
+
+	if (!p) {
+		ast_log(LOG_WARNING, "Unable to build pvt data for '%s'\n", (char*)data);
+		return NULL;
+	}
+	ast_mutex_lock(&p->lock);
+
+	/* This is an outgoing call, since ooh323_request is called */
+	ast_set_flag(p, H323_OUTGOING);
+
+	ast_copy_string(tmp, data, sizeof(data));
+
+	dest = strchr(tmp, '/');
+
+	if (dest) {  
+		*dest = '\0';
+		dest++;
+		ext = tmp;
+	} else if ((dest = strchr(tmp, '@'))) {
+		*dest = '\0';
+		dest++;
+		ext = tmp;
+	} else {
+		dest = tmp;
+		ext = NULL;
+	}
+
+#if 0
+	if ((sport = strchr(dest, ':'))) {
+		*sport = '\0';
+		sport++;
+		port = atoi(sport);
+	}
+#endif
+
+	if (dest) {
+		peer = find_peer(dest, port);
+	} else{
+		ast_log(LOG_ERROR, "Destination format is not supported\n");
+		return NULL;
+	}
+
+	if (peer) {
+		p->username = strdup(peer->name);
+		p->host = strdup(peer->ip);
+		p->port = peer->port;
+		/* Disable gk as we are going to call a known peer*/
+		OO_SETFLAG(p->flags, H323_DISABLEGK);
+
+		if (ext)
+			ast_copy_string(p->exten, ext, sizeof(p->exten));
+
+		if (peer->capability & format) {
+			p->capability = peer->capability & format;
+		} else {
+		  p->capability = peer->capability;
+		}
+		memcpy(&p->prefs, &peer->prefs, sizeof(struct ast_codec_pref));
+		p->dtmfmode = peer->dtmfmode;
+		ast_copy_string(p->accountcode, peer->accountcode, sizeof(p->accountcode));
+		p->amaflags = peer->amaflags;
+	} else {
+		p->dtmfmode = gDTMFMode;
+		p->capability = gCapability;
+
+		memcpy(&p->prefs, &gPrefs, sizeof(struct ast_codec_pref));
+		p->username = strdup(dest);
+
+		p->host = strdup(dest);
+		if (port > 0) {
+			p->port = port;
+		}
+		if (ext) {
+			ast_copy_string(p->exten, ext, sizeof(p->exten));
+		}
+	}
+
+
+	chan = ooh323_new(p, AST_STATE_DOWN, p->username);
+	
+	ast_mutex_unlock(&p->lock);
+
+	if (!chan) {
+		ast_mutex_lock(&iflock);
+		ooh323_destroy(p);
+		ast_mutex_unlock(&iflock);
+	}
+
+	restart_monitor();
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_request\n");
+
+	return chan;
+
+}
+
+
+static struct ooh323_pvt* find_call(ooCallData *call)
+{
+	struct ooh323_pvt *p;
+
+	if (gH323Debug)
+		ast_verbose("---   find_call\n");
+
+	ast_mutex_lock(&iflock);
+
+	for (p = iflist; p; p = p->next) {
+		if (p->callToken && !strcmp(p->callToken, call->callToken)) {
+			break;
+		}
+	}
+	ast_mutex_unlock(&iflock);
+
+	if (gH323Debug)
+		ast_verbose("+++   find_call\n");
+
+	return p;
+}
+
+struct ooh323_user *find_user(const char * name, const char* ip)
+{
+	struct ooh323_user *user;
+
+	if (gH323Debug)
+		ast_verbose("---   find_user\n");
+
+	ast_mutex_lock(&userl.lock);
+	for (user = userl.users; user; user = user->next) {
+		if (ip && user->mUseIP && !strcmp(user->mIP, ip)) {
+			break;
+		}
+		if (name && !strcmp(user->name, name)) {
+			break;
+		}
+	}
+	ast_mutex_unlock(&userl.lock);
+
+	if (gH323Debug)
+		ast_verbose("+++   find_user\n");
+
+	return user;
+}
+
+struct ooh323_peer *find_friend(const char *name, int port)
+{
+	struct ooh323_peer *peer;  
+
+	if (gH323Debug)
+		ast_verbose("---   find_friend \"%s\"\n", name);
+
+
+	ast_mutex_lock(&peerl.lock);
+	for (peer = peerl.peers; peer; peer = peer->next) {
+		if (gH323Debug) {
+			ast_verbose("		comparing with \"%s\"\n", peer->ip);
+		}
+		if (!strcmp(peer->ip, name)) {
+			if (port <= 0 || (port > 0 && peer->port == port)) {
+				break;
+			}
+		}
+	}
+	ast_mutex_unlock(&peerl.lock);
+
+	if (gH323Debug) {
+		if (peer) {
+			ast_verbose("		found matching friend\n");
+		}
+		ast_verbose("+++   find_friend \"%s\"\n", name);
+	}
+
+	return peer;		
+}
+
+
+struct ooh323_peer *find_peer(const char * name, int port)
+{
+	struct ooh323_peer *peer;
+
+	if (gH323Debug)
+		ast_verbose("---   find_peer \"%s\"\n", name);
+
+	ast_mutex_lock(&peerl.lock);
+	for (peer = peerl.peers; peer; peer = peer->next) {
+		if (gH323Debug) {
+			ast_verbose("		comparing with \"%s\"\n", peer->ip);
+		}
+		if (!strcasecmp(peer->name, name))
+			break;
+		if (peer->h323id && !strcasecmp(peer->h323id, name))
+			break;
+		if (peer->e164 && !strcasecmp(peer->e164, name))
+			break;
+		/*
+		if (!strcmp(peer->ip, name)) {
+			if (port > 0 && peer->port == port) { break; }
+			else if (port <= 0) { break; }
+		}
+		*/
+	}
+	ast_mutex_unlock(&peerl.lock);
+
+	if (gH323Debug) {
+		if (peer) {
+			ast_verbose("		found matching peer\n");
+		}
+		ast_verbose("+++   find_peer \"%s\"\n", name);
+	}
+
+	return peer;		
+}
+
+static int ooh323_digit_begin(struct ast_channel *chan, char digit)
+{
+	char dtmf[2];
+	struct ooh323_pvt *p = (struct ooh323_pvt *) chan->tech_pvt;
+	
+	if (gH323Debug)
+		ast_verbose("---   ooh323_digit_begin\n");
+
+	if (!p) {
+		ast_log(LOG_ERROR, "No private structure for call\n");
+		return -1;
+	}
+	ast_mutex_lock(&p->lock);
+	if (p->rtp && (p->dtmfmode & H323_DTMF_RFC2833)) {
+		ast_rtp_senddigit_begin(p->rtp, digit);
+	} else if (((p->dtmfmode & H323_DTMF_Q931) ||
+						 (p->dtmfmode & H323_DTMF_H245ALPHANUMERIC) ||
+						 (p->dtmfmode & H323_DTMF_H245SIGNAL))) {
+		dtmf[0] = digit;
+		dtmf[1] = '\0';
+		ast_mutex_lock(&ooh323c_cmd_lock);
+		ooSendDTMFDigit(p->callToken, dtmf);
+		ast_mutex_unlock(&ooh323c_cmd_lock);
+	}
+	ast_mutex_unlock(&p->lock);
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_digit_begin\n");
+
+	return 0;
+}
+
+static int ooh323_digit_end(struct ast_channel *chan, char digit, unsigned int duration)
+{
+	struct ooh323_pvt *p = (struct ooh323_pvt *) chan->tech_pvt;
+
+	if (gH323Debug)
+		ast_verbose("---   ooh323_digit_end\n");
+
+	if (!p) {
+		ast_log(LOG_ERROR, "No private structure for call\n");
+		return -1;
+	}
+	ast_mutex_lock(&p->lock);
+	if (p->rtp && (p->dtmfmode & H323_DTMF_RFC2833)) 
+		ast_rtp_senddigit_end(p->rtp, digit);
+
+	ast_mutex_unlock(&p->lock);
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_digit_end\n");
+
+	return 0;
+}
+
+
+static int ooh323_call(struct ast_channel *ast, char *dest, int timeout)
+{
+	struct ooh323_pvt *p = ast->tech_pvt;
+	char destination[256];
+	int res = 0;
+	const char *val = NULL;
+	ooCallOptions opts = {
+		.fastStart = TRUE,
+		.tunneling = TRUE,
+		.disableGk = TRUE,
+		.callMode = OO_CALLMODE_AUDIOCALL
+	};
+	if (gH323Debug)
+		ast_verbose("---   ooh323_call- %s\n", dest);
+
+	if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
+		ast_log(LOG_WARNING, "ooh323_call called on %s, neither down nor "
+									"reserved\n", ast->name);
+		return -1;
+	}
+	ast_mutex_lock(&p->lock);
+	ast_set_flag(p, H323_OUTGOING);
+	if (ast->cid.cid_num) {
+		if (p->callerid_num) {
+			free(p->callerid_num);
+		}
+		p->callerid_num = strdup(ast->cid.cid_num);
+	}
+
+	if (ast->cid.cid_name) {
+		if (p->callerid_name) {
+			free(p->callerid_name);
+		}
+		p->callerid_name = strdup(ast->cid.cid_name);
+	}
+	else{
+		ast->cid.cid_name = strdup(gCallerID);
+		if (p->callerid_name) {
+			free(p->callerid_name);
+		}
+		p->callerid_name = strdup(ast->cid.cid_name);
+	}
+
+	/* Retrieve vars */
+
+
+	if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323ID"))) {
+		ast_copy_string(p->caller_h323id, val, sizeof(p->caller_h323id));
+	}
+	
+	if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323DIALEDDIGITS"))) {
+		ast_copy_string(p->caller_dialedDigits, val, sizeof(p->caller_dialedDigits));
+		if (!p->callerid_num) {
+			p->callerid_num = strdup(val);
+		}
+	}
+
+	if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323EMAIL"))) {
+		ast_copy_string(p->caller_email, val, sizeof(p->caller_email));
+	}
+
+	if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323URL"))) {
+		ast_copy_string(p->caller_url, val, sizeof(p->caller_url));
+	}
+
+
+	if (!(p->callToken = (char*)malloc(AST_MAX_EXTENSION))) {
+		ast_mutex_unlock(&p->lock);
+		ast_log(LOG_ERROR, "Failed to allocate memory for callToken\n");
+		return -1; /* TODO: need to clean/hangup?? */
+	}		
+
+	if (p->host && p->port != 0)
+		snprintf(destination, sizeof(destination), "%s:%d", p->host, p->port);
+	else if (p->host)
+		snprintf(destination, sizeof(destination), "%s", p->host);
+	else
+		ast_copy_string(destination, dest, sizeof(destination));
+
+	ast_mutex_lock(&ooh323c_cmd_lock);
+	if (OO_TESTFLAG(p->flags, H323_DISABLEGK))
+		res = ooMakeCall(destination, p->callToken, AST_MAX_EXTENSION, &opts);
+	else
+		res = ooMakeCall(destination, p->callToken, AST_MAX_EXTENSION, NULL);
+	ast_mutex_unlock(&ooh323c_cmd_lock);
+
+	ast_mutex_unlock(&p->lock);
+	if (res != OO_OK) {
+		ast_log(LOG_ERROR, "Failed to make call\n");
+		return -1; /* TODO: cleanup */
+	}
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_call\n");
+
+  return 0;
+}
+
+static int ooh323_hangup(struct ast_channel *ast)
+{
+	struct ooh323_pvt *p = ast->tech_pvt;
+
+	if (gH323Debug)
+		ast_verbose("---   ooh323_hangup\n");
+
+	if (p) {
+		ast_mutex_lock(&p->lock);
+
+		if (gH323Debug)
+			ast_verbose("	 hanging %s\n", p->username);
+		ast->tech_pvt = NULL; 
+		if (!ast_test_flag(p, H323_ALREADYGONE)) {
+			ast_mutex_lock(&ooh323c_cmd_lock);
+			ooHangCall(p->callToken, 
+				 ooh323_convert_hangupcause_asteriskToH323(p->owner->hangupcause));
+			ast_mutex_unlock(&ooh323c_cmd_lock);
+			ast_set_flag(p, H323_ALREADYGONE);
+			/* ast_mutex_unlock(&p->lock); */
+		} else {
+			ast_set_flag(p, H323_NEEDDESTROY);
+		}
+		/* detach channel here */
+		if (p->owner) {
+			p->owner->tech_pvt = NULL;
+			p->owner = NULL;
+		}
+
+		ast_mutex_unlock(&p->lock);
+		ast_mutex_lock(&usecnt_lock);
+		usecnt--;
+		ast_mutex_unlock(&usecnt_lock);
+
+		/* Notify the module monitors that use count for resource has changed */
+		ast_update_use_count();
+	  
+	} else {
+		ast_log(LOG_ERROR, "No call to hangup\n" );
+		return -1;
+	}
+	
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_hangup\n");
+
+  return 0;
+}
+
+static int ooh323_answer(struct ast_channel *ast)
+{
+	struct ooh323_pvt *p = ast->tech_pvt;
+
+	if (gH323Debug)
+		ast_verbose("--- ooh323_answer\n");
+
+	ast_mutex_lock(&p->lock);
+	if (ast->_state != AST_STATE_UP) {
+		ast_channel_lock(ast);
+		ast_setstate(ast, AST_STATE_UP);
+		ast_debug(1, "ooh323_answer(%s)\n", ast->name);
+		ast_channel_unlock(ast);
+		ast_mutex_lock(&ooh323c_cmd_lock);
+		ooAnswerCall(p->callToken);
+		ast_mutex_unlock(&ooh323c_cmd_lock);
+	}
+	ast_mutex_unlock(&p->lock);
+
+	if (gH323Debug)
+		ast_verbose("+++ ooh323_answer\n");
+
+  return 0;
+}
+
+static struct ast_frame *ooh323_read(struct ast_channel *ast)
+{
+	struct ast_frame *fr;
+	static struct ast_frame null_frame = { AST_FRAME_NULL, };
+	struct ooh323_pvt *p = ast->tech_pvt;
+
+	ast_mutex_lock(&p->lock);
+	if (p->rtp)
+		fr = ooh323_rtp_read(ast, p);
+	else
+		fr = &null_frame;
+	/* time(&p->lastrtprx); */
+	ast_mutex_unlock(&p->lock);
+	return fr;
+}
+
+static int ooh323_write(struct ast_channel *ast, struct ast_frame *f)
+{
+	struct ooh323_pvt *p = ast->tech_pvt;
+	int res = 0;
+
+	if (f->frametype == AST_FRAME_VOICE) {
+		if (!(f->subclass & ast->nativeformats)) {
+			ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native "
+									  "formats is %d (read/write = %d/%d)\n",
+									f->subclass, ast->nativeformats, ast->readformat,
+										ast->writeformat);
+			return 0;
+		}
+		if (p) {
+			ast_mutex_lock(&p->lock);
+			if (p->rtp)
+				res = ast_rtp_write(p->rtp, f);
+			ast_mutex_unlock(&p->lock);
+		}
+	} else if (f->frametype == AST_FRAME_IMAGE) {
+		return 0;
+	} else {
+		ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", 
+									 f->frametype);
+		return 0;
+	}
+
+	return res;
+}
+
+static int ooh323_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
+{
+
+	struct ooh323_pvt *p = (struct ooh323_pvt *) ast->tech_pvt;
+	char *callToken = (char *)NULL;
+
+	ast_mutex_lock(&p->lock);
+	callToken = (p->callToken ? strdup(p->callToken) : NULL);
+	ast_mutex_unlock(&p->lock);
+
+	if (!callToken) {
+		if (gH323Debug)
+			ast_verbose("	ooh323_indicate - No callToken\n");
+		return -1;
+	}
+
+	if (gH323Debug)
+		ast_verbose("----- ooh323_indicate %d on call %s\n", condition, callToken);
+	 
+
+	switch (condition) {
+	case AST_CONTROL_CONGESTION:
+		if (!ast_test_flag(p, H323_ALREADYGONE)) {
+			ast_mutex_lock(&ooh323c_cmd_lock);
+			ooHangCall(callToken, OO_REASON_LOCAL_CONGESTED);
+			ast_mutex_unlock(&ooh323c_cmd_lock);
+			ast_set_flag(p, H323_ALREADYGONE);
+		}
+		break;
+	case AST_CONTROL_BUSY:
+		if (!ast_test_flag(p, H323_ALREADYGONE)) {
+			ast_mutex_lock(&ooh323c_cmd_lock);
+			ooHangCall(callToken, OO_REASON_LOCAL_BUSY);
+			ast_mutex_unlock(&ooh323c_cmd_lock);
+			ast_set_flag(p, H323_ALREADYGONE);
+		}
+		break;
+	case AST_CONTROL_HOLD:
+		ast_moh_start(ast, data, NULL);		
+		break;
+	case AST_CONTROL_UNHOLD:
+		ast_moh_stop(ast);
+		break;
+	case AST_CONTROL_PROCEEDING:
+	case AST_CONTROL_RINGING:
+	case AST_CONTROL_PROGRESS:
+	case -1:
+		break;
+	default:
+		ast_log(LOG_WARNING, "Don't know how to indicate condition %d on %s\n",
+									condition, callToken);
+	}
+
+	if (gH323Debug)
+		ast_verbose("++++  ooh323_indicate %d on %s\n", condition, callToken);
+
+
+	return -1;
+}
+
+static int ooh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
+{
+	struct ooh323_pvt *p = newchan->tech_pvt;
+
+	if (gH323Debug)
+		ast_verbose("--- ooh323c ooh323_fixup\n");
+
+	ast_mutex_lock(&p->lock);
+	if (p->owner != oldchan) {
+		ast_log(LOG_WARNING, "Old channel wasn't %p but was %p\n", oldchan, p->owner);
+		ast_mutex_unlock(&p->lock);
+		return -1;
+	}
+
+	if (p->owner == oldchan) {
+		p->owner = newchan;
+	} else {
+		p->owner = oldchan;
+	}
+
+	ast_mutex_unlock(&p->lock);
+
+	if (gH323Debug)
+		ast_verbose("+++ ooh323c ooh323_fixup \n");
+
+	return 0;
+}
+
+
+void ooh323_set_write_format(ooCallData *call, int fmt)
+{
+#if 0
+	struct ooh323_pvt *p = NULL;
+	char formats[512];
+#ifdef print_debug
+	printf("---   ooh323_update_writeformat %s\n", 
+										ast_getformatname_multiple(formats,512, fmt));
+#endif
+	
+	p = find_call(call);
+	if (!p) {
+		ast_log(LOG_ERROR, "No matching call found for %s\n", call->callToken);
+		return;
+	}
+
+	ast_mutex_lock(&p->lock);
+
+	p->writeformat = fmt;
+	ast_mutex_unlock(&p->lock);
+
+	if (p->owner) {
+	  printf("Writeformat before update %s\n", 
+				  ast_getformatname_multiple(formats,512, p->owner->writeformat));
+	  ast_set_write_format(p->owner, fmt);
+	}
+	else
+	  ast_log(LOG_ERROR, "No owner found\n");
+
+
+#ifdef print_debug
+  printf("+++   ooh323_update_writeformat\n");
+#endif
+#endif
+}
+
+
+void ooh323_set_read_format(ooCallData *call, int fmt)
+{
+#if 0
+	struct ooh323_pvt *p = NULL;
+	char formats[512];
+#ifdef print_debug
+	printf("---   ooh323_update_readformat %s\n", 
+											ast_getformatname_multiple(formats,512, fmt));
+#endif
+
+	p = find_call(call);
+	if (!p) {
+		ast_log(LOG_ERROR, "No matching call found for %s\n", call->callToken);
+		return;
+	}
+
+	ast_mutex_lock(&p->lock);
+	p->readformat = fmt;
+	ast_mutex_unlock(&p->lock);
+	ast_set_read_format(p->owner, fmt);	
+	
+#ifdef print_debug
+  printf("+++   ooh323_update_readformat\n");
+#endif
+#endif
+}
+
+int onAlerting(ooCallData *call)
+{
+	struct ooh323_pvt *p = NULL;
+	struct ast_channel *c = NULL;
+
+	if (gH323Debug)
+		ast_verbose("--- onAlerting %s\n", call->callToken);
+
+	if (!(p = find_call(call))) {
+		ast_log(LOG_ERROR, "No matching call found\n");
+		return -1;
+	}  
+	ast_mutex_lock(&p->lock);
+	if (!ast_test_flag(p, H323_OUTGOING)) {
+		if (!(c = ooh323_new(p, AST_STATE_RING, p->username))) {
+			ast_mutex_unlock(&p->lock);
+			ast_log(LOG_ERROR, "Could not create ast_channel\n");
+			return -1;
+		}
+		ast_mutex_unlock(&p->lock);
+	} else {
+		if (!p->owner) {
+			ast_mutex_unlock(&p->lock);
+			ast_log(LOG_ERROR, "Channel has no owner\n");
+			return 0;
+		}
+		c = p->owner;
+		ast_mutex_unlock(&p->lock);
+		ast_channel_lock(c);
+		ast_setstate(c, AST_STATE_RINGING);
+		ast_channel_unlock(c);
+		ast_queue_control(c, AST_CONTROL_RINGING);
+	}
+
+	if (gH323Debug)
+		ast_verbose("+++ onAlerting %s\n", call->callToken);
+
+	return OO_OK;
+}
+
+/**
+  * Callback for sending digits from H.323 up to asterisk
+  *
+  */
+int ooh323_onReceivedDigit(OOH323CallData *call, const char *digit)
+{
+	struct ooh323_pvt *p = NULL;
+	struct ast_frame f;
+	int res;
+
+	ast_debug(1, "Received Digit: %c\n", digit[0]);
+	p = find_call(call);
+	if (!p) {
+		ast_log(LOG_ERROR, "Failed to find a matching call.\n");
+		return -1;
+	}
+	if (!p->owner) {
+		ast_log(LOG_ERROR, "Channel has no owner\n");
+		return -1;
+	}
+	ast_mutex_lock(&p->lock);
+	memset(&f, 0, sizeof(f));
+	f.frametype = AST_FRAME_DTMF;
+	f.subclass = digit[0];
+	f.datalen = 0;
+	f.samples = 800;
+	f.offset = 0;
+	f.data.ptr = NULL;
+	f.mallocd = 0;
+	f.src = "SEND_DIGIT";
+	ast_mutex_unlock(&p->lock);
+	res = ast_queue_frame(p->owner, &f);
+	return res;
+}
+
+int ooh323_onReceivedSetup(ooCallData *call, Q931Message *pmsg)
+{
+	struct ooh323_pvt *p = NULL;
+	struct ooh323_user *user = NULL;
+	ooAliases *alias = NULL;
+	char *at = NULL;
+	char number [OO_MAX_NUMBER_LENGTH];
+
+	if (gH323Debug)
+		ast_verbose("---   ooh323_onReceivedSetup %s\n", call->callToken);
+
+
+	if (!(p = ooh323_alloc(call->callReference, call->callToken))) {
+		ast_log(LOG_ERROR, "Failed to create a new call.\n");
+		return -1;
+	}
+	ast_mutex_lock(&p->lock);
+	ast_clear_flag(p, H323_OUTGOING);
+  
+
+	if (call->remoteDisplayName) {
+		p->callerid_name = strdup(call->remoteDisplayName);
+	}
+
+	if (ooCallGetCallingPartyNumber(call, number, OO_MAX_NUMBER_LENGTH) == OO_OK) {
+		p->callerid_num = strdup(number);
+	}
+
+	if (call->remoteAliases) {
+		for (alias = call->remoteAliases; alias; alias = alias->next) {
+			if (alias->type == T_H225AliasAddress_h323_ID) {
+				if (!p->callerid_name) {
+					p->callerid_name = strdup(alias->value);
+				}
+				ast_copy_string(p->caller_h323id, alias->value, sizeof(p->caller_h323id));
+			} else if (alias->type == T_H225AliasAddress_dialedDigits) {
+				if (!p->callerid_num) {
+					p->callerid_num = strdup(alias->value);
+				}
+				ast_copy_string(p->caller_dialedDigits, alias->value, 
+															sizeof(p->caller_dialedDigits));
+			} else if (alias->type == T_H225AliasAddress_email_ID) {
+				ast_copy_string(p->caller_email, alias->value, sizeof(p->caller_email));
+			} else if (alias->type == T_H225AliasAddress_url_ID) {
+				ast_copy_string(p->caller_url, alias->value, sizeof(p->caller_url));
+			}
+		}
+	}
+
+	number[0] = '\0';
+	if (ooCallGetCalledPartyNumber(call, number, OO_MAX_NUMBER_LENGTH) == OO_OK) {
+		ast_copy_string(p->exten, number, sizeof(p->exten));
+	} else {
+		update_our_aliases(call, p);
+		if (!ast_strlen_zero(p->callee_dialedDigits)) {
+			ast_copy_string(p->exten, p->callee_dialedDigits, sizeof(p->exten));
+		} else if (!ast_strlen_zero(p->callee_h323id)) {
+			ast_copy_string(p->exten, p->callee_h323id, sizeof(p->exten));
+		} else if (!ast_strlen_zero(p->callee_email)) {
+			ast_copy_string(p->exten, p->callee_email, sizeof(p->exten));
+			if ((at = strchr(p->exten, '@'))) {
+				*at = '\0';
+			}
+		}
+	}
+
+	/* if no extension found, set to default 's' */
+	if (ast_strlen_zero(p->exten)) {
+		ast_copy_string(p->exten, "s", sizeof(p->exten));
+	}
+
+	if (!p->callerid_name) {
+		p->callerid_name = strdup(call->remoteIP);
+	}
+	
+	if (p->callerid_name) {
+		if ((user = find_user(p->callerid_name, call->remoteIP))) {
+			ast_mutex_lock(&user->lock);
+			p->username = strdup(user->name);
+			ast_copy_string(p->context, user->context, sizeof(p->context));
+			ast_copy_string(p->accountcode, user->accountcode, sizeof(p->accountcode));
+			p->amaflags = user->amaflags;
+			p->capability = user->capability;
+			memcpy(&p->prefs, &user->prefs, sizeof(struct ast_codec_pref));
+			p->dtmfmode = user->dtmfmode;
+			/* Since, call is coming from a pbx user, no need to use gk */
+			OO_SETFLAG(p->flags, H323_DISABLEGK);
+			OO_SETFLAG(call->flags, OO_M_DISABLEGK);
+			ast_mutex_unlock(&user->lock);
+		}
+	}
+
+
+	ooh323c_set_capability_for_call(call, &p->prefs, p->capability, p->dtmfmode);
+	configure_local_rtp(p, call);
+
+	ast_mutex_unlock(&p->lock);
+
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_onReceivedSetup - Determined context %s, "
+						"extension %s\n", p->context, p->exten);
+
+	return OO_OK;
+}
+
+
+
+int onNewCallCreated(ooCallData *call)
+{
+	struct ooh323_pvt *p = NULL;
+	int i = 0;
+
+	if (gH323Debug)
+		ast_verbose("---   onNewCallCreated %s\n", call->callToken);
+
+	if (!strcmp(call->callType, "outgoing")) {
+		p = find_call(call);
+		if (!p) {
+			ast_log(LOG_ERROR, "No matching call found for outgoing call\n");
+			return -1;
+		}
+		ast_mutex_lock(&p->lock);
+		if (p->callerid_name) {
+			ooCallSetCallerId(call, p->callerid_name);
+		}
+		if (p->callerid_num) {
+			i = 0;
+			while (*(p->callerid_num + i) != '\0') {
+				if (!isdigit(*(p->callerid_num + i))) {
+					break;
+				}
+				i++;
+			}
+			if (*(p->callerid_num + i) == '\0') {
+				ooCallSetCallingPartyNumber(call, p->callerid_num);
+			} else {
+				if (!p->callerid_name) {
+					ooCallSetCallerId(call, p->callerid_num);
+				}
+			}
+		}
+		
+		if (!ast_strlen_zero(p->caller_h323id))
+			ooCallAddAliasH323ID(call, p->caller_h323id);
+
+		if (!ast_strlen_zero(p->caller_dialedDigits)) {
+			if (gH323Debug) {
+				ast_verbose("Setting dialed digits %s\n", p->caller_dialedDigits);
+			}
+			ooCallAddAliasDialedDigits(call, p->caller_dialedDigits);
+		} else if (p->callerid_num) {
+			if (ooIsDailedDigit(p->callerid_num)) {
+				if (gH323Debug) {
+					ast_verbose("setting callid number %s\n", p->callerid_num);
+				}
+				ooCallAddAliasDialedDigits(call, p->callerid_num);
+			} else if (ast_strlen_zero(p->caller_h323id)) {
+				ooCallAddAliasH323ID(call, p->callerid_num);
+			}
+		}
+  
+
+		if (!ast_strlen_zero(p->exten))  {
+			if (ooIsDailedDigit(p->exten)) {
+				ooCallSetCalledPartyNumber(call, p->exten);
+				ooCallAddRemoteAliasDialedDigits(call, p->exten);
+			} else {
+			  ooCallAddRemoteAliasH323ID(call, p->exten);
+			}
+		}
+
+		if (gH323Debug) {
+			char prefsBuf[256];
+			ast_codec_pref_string(&p->prefs, prefsBuf, sizeof(prefsBuf));
+			ast_verbose(" Outgoing call %s(%s) - Codec prefs - %s\n", 
+						  p->username?p->username:"NULL", call->callToken, prefsBuf);
+		}
+
+		ooh323c_set_capability_for_call(call, &p->prefs, p->capability, p->dtmfmode);
+
+		configure_local_rtp(p, call);
+		ast_mutex_unlock(&p->lock);
+	}
+	if (gH323Debug)
+		ast_verbose("+++   onNewCallCreated %s\n", call->callToken);
+
+	return OO_OK;
+}
+
+int onCallEstablished(ooCallData *call)
+{
+	struct ooh323_pvt *p = NULL;
+
+	if (gH323Debug)
+		ast_verbose("---   onCallEstablished %s\n", call->callToken);
+
+	if (!(p = find_call(call))) {
+		ast_log(LOG_ERROR, "Failed to find a matching call.\n");
+		return -1;
+	}
+	ast_mutex_lock(&p->lock);
+	if (!p->owner) {
+		ast_mutex_unlock(&p->lock);
+		ast_log(LOG_ERROR, "Channel has no owner\n");
+		return -1;
+	}
+	
+	while (ast_channel_trylock(p->owner)) {
+		ast_debug(1,"Failed to grab lock, trying again\n");
+		ast_mutex_unlock(&p->lock);
+		usleep(1);
+		ast_mutex_lock(&p->lock);
+	}	 
+	if (p->owner->_state != AST_STATE_UP) {
+		ast_setstate(p->owner, AST_STATE_UP);
+	}
+	ast_channel_unlock(p->owner);
+	if (ast_test_flag(p, H323_OUTGOING)) {
+		struct ast_channel* c = p->owner;
+		ast_mutex_unlock(&p->lock);
+		ast_queue_control(c, AST_CONTROL_ANSWER);
+	} else {
+		ast_mutex_unlock(&p->lock);
+	}
+
+	if (gH323Debug)
+		ast_verbose("+++   onCallEstablished %s\n", call->callToken);
+
+	return OO_OK;
+}
+
+int onCallCleared(ooCallData *call)
+{
+	struct ooh323_pvt *p = NULL;
+	int ownerLock = 0;
+
+	if (gH323Debug)
+		ast_verbose("---   onCallCleared %s \n", call->callToken);
+
+	p = find_call(call); 
+	if (!p) {
+		return 0;
+	}
+	ast_mutex_lock(&p->lock);
+  
+	while (p->owner) {
+		if (ast_channel_trylock(p->owner)) {
+			ooTrace(OOTRCLVLINFO, "Failed to grab lock, trying again\n");
+			ast_debug(1,"Failed to grab lock, trying again\n");
+			ast_mutex_unlock(&p->lock);
+			usleep(1);
+			ast_mutex_lock(&p->lock);
+		} else {
+			ownerLock = 1;
+			break;
+		}
+	}
+
+	if (ownerLock) {
+		if (!ast_test_flag(p, H323_ALREADYGONE)) { 
+
+			/* NOTE: Channel is not detached yet */
+			ast_set_flag(p, H323_ALREADYGONE);
+			p->owner->hangupcause = 
+				ooh323_convert_hangupcause_h323ToAsterisk(call->callEndReason);
+			p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
+			ast_channel_unlock(p->owner);
+			ast_queue_hangup(p->owner);
+			ast_mutex_unlock(&p->lock);
+			return OO_OK;
+		}
+		ast_channel_unlock(p->owner);
+	}
+	ast_set_flag(p, H323_NEEDDESTROY);
+	ast_mutex_unlock(&p->lock);
+
+	if (gH323Debug)
+		ast_verbose("+++   onCallCleared\n");
+
+	return OO_OK;
+}
+
+#if 0
+static void ooh323_delete_user(struct ooh323_user *user)
+{
+	struct ooh323_user *prev = NULL, *cur = NULL;
+
+	if (gH323Debug)
+		ast_verbose("---   ooh323_delete_user\n");
+
+	if (user) {	
+		cur = userl.users;
+		ast_mutex_lock(&userl.lock);
+		while (cur) {
+			if (cur == user) break;
+			prev = cur;
+			cur = cur->next;
+		}
+
+		if (cur) {
+			if (prev)
+				prev->next = cur->next;
+			else
+				userl.users = cur->next;
+		}
+		ast_mutex_unlock(&userl.lock);
+
+		free(user);
+	}  
+
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_delete_user\n");
+
+}
+#endif
+
+void ooh323_delete_peer(struct ooh323_peer *peer)
+{
+	struct ooh323_peer *prev = NULL, *cur = NULL;
+
+	if (gH323Debug)
+		ast_verbose("---   ooh323_delete_peer\n");
+
+	if (peer) {	
+		ast_mutex_lock(&peerl.lock);
+		for (cur = peerl.peers; cur; prev = cur, cur = cur->next) {
+			if (cur == peer) {
+				break;
+			}
+		}
+
+		if (cur) {
+			if (prev) {
+				prev->next = cur->next;
+			} else {
+				peerl.peers = cur->next;
+			}
+		}
+		ast_mutex_unlock(&peerl.lock);
+
+		if (peer->h323id)
+			free(peer->h323id);
+		if (peer->email)
+			free(peer->email);
+		if (peer->url)
+			free(peer->url);
+		if (peer->e164)
+			free(peer->e164);
+
+		free(peer);
+	}  
+
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_delete_peer\n");
+}
+
+
+
+static struct ooh323_user *build_user(const char *name, struct ast_variable *v)
+{
+	struct ooh323_user *user = NULL;
+
+	if (gH323Debug)
+		ast_verbose("---   build_user\n");
+
+	user = ast_calloc(1, sizeof(*user));
+	if (user) {
+		ast_mutex_init(&user->lock);
+		ast_copy_string(user->name, name, sizeof(user->name));
+		user->capability = gCapability;
+		memcpy(&user->prefs, &gPrefs, sizeof(user->prefs));
+		user->rtptimeout = gRTPTimeout;
+		user->dtmfmode = gDTMFMode;
+		/* set default context */
+		ast_copy_string(user->context, gContext, sizeof(user->context));
+		ast_copy_string(user->accountcode, gAccountcode, sizeof(user->accountcode));
+		user->amaflags = gAMAFLAGS;
+
+		while (v) {
+			if (!strcasecmp(v->name, "context")) {
+				ast_copy_string(user->context, v->value, sizeof(user->context));
+			} else if (!strcasecmp(v->name, "incominglimit")) {
+				user->incominglimit = atoi(v->value);
+				if (user->incominglimit < 0)
+					user->incominglimit = 0;
+			} else if (!strcasecmp(v->name, "accountcode")) {
+				ast_copy_string(user->accountcode, v->value, sizeof(user->accountcode));
+			} else if (!strcasecmp(v->name, "rtptimeout")) {
+				user->rtptimeout = atoi(v->value);
+				if (user->rtptimeout < 0)
+					user->rtptimeout = gRTPTimeout;
+			} else if (!strcasecmp(v->name, "disallow")) {
+				ast_parse_allow_disallow(&user->prefs, &user->capability, 
+												 v->value, 0);
+			} else if (!strcasecmp(v->name, "allow")) {
+				const char* tcodecs = v->value;
+				if (!strcasecmp(v->value, "all")) {
+					tcodecs = "ulaw,alaw,g729,g723,gsm";
+				}
+				ast_parse_allow_disallow(&user->prefs, &user->capability, 
+												 tcodecs, 1);
+			} else if (!strcasecmp(v->name, "amaflags")) {
+				user->amaflags = ast_cdr_amaflags2int(v->value);
+			} else if (!strcasecmp(v->name, "ip")) {
+				ast_copy_string(user->mIP, v->value, sizeof(user->mIP));
+				user->mUseIP = 1;
+			} else if (!strcasecmp(v->name, "dtmfmode")) {
+				if (!strcasecmp(v->value, "rfc2833"))
+					user->dtmfmode = H323_DTMF_RFC2833;
+				else if (!strcasecmp(v->value, "q931keypad"))
+					user->dtmfmode = H323_DTMF_Q931;
+				else if (!strcasecmp(v->value, "h245alphanumeric"))
+					user->dtmfmode = H323_DTMF_H245ALPHANUMERIC;
+				else if (!strcasecmp(v->value, "h245signal"))
+					user->dtmfmode = H323_DTMF_H245SIGNAL;
+			}
+			v = v->next;
+		}
+	}
+
+	if (gH323Debug)
+		ast_verbose("+++   build_user\n");
+
+	return user;
+}
+
+static struct ooh323_peer *build_peer(const char *name, struct ast_variable *v, int friend_type)
+{
+	struct ooh323_peer *peer = NULL;
+
+	if (gH323Debug)
+		ast_verbose("---   build_peer\n");
+
+	peer = ast_calloc(1, sizeof(*peer));
+	if (peer) {
+		memset(peer, 0, sizeof(struct ooh323_peer));
+		ast_mutex_init(&peer->lock);
+		ast_copy_string(peer->name, name, sizeof(peer->name));
+		peer->capability = gCapability;
+		memcpy(&peer->prefs, &gPrefs, sizeof(struct ast_codec_pref));
+		peer->rtptimeout = gRTPTimeout;
+		ast_copy_string(peer->accountcode, gAccountcode, sizeof(peer->accountcode));
+		peer->amaflags = gAMAFLAGS;
+		peer->dtmfmode = gDTMFMode;
+		if (0 == friend_type) {
+			peer->mFriend = 1;
+		}
+
+		while (v) {
+			if (!strcasecmp(v->name, "h323id")) {
+				if (!(peer->h323id = ast_strdup(v->value))) {
+					ast_log(LOG_ERROR, "Could not allocate memory for h323id of "
+											 "peer %s\n", name);
+					ooh323_delete_peer(peer);
+					return NULL;
+				}
+			} else if (!strcasecmp(v->name, "e164")) {
+				if (!(peer->e164 = ast_strdup(v->value))) {
+					ast_log(LOG_ERROR, "Could not allocate memory for e164 of "
+											 "peer %s\n", name);
+					ooh323_delete_peer(peer);
+					return NULL;
+				}
+			} else  if (!strcasecmp(v->name, "email")) {
+				if (!(peer->email = ast_strdup(v->value))) {
+					ast_log(LOG_ERROR, "Could not allocate memory for email of "
+											 "peer %s\n", name);
+					ooh323_delete_peer(peer);
+					return NULL;
+				}
+			} else if (!strcasecmp(v->name, "url")) {
+				if (!(peer->url = ast_strdup(v->value))) {
+					ast_log(LOG_ERROR, "Could not allocate memory for h323id of "
+											 "peer %s\n", name);
+					ooh323_delete_peer(peer);
+					return NULL;
+				}
+			} else if (!strcasecmp(v->name, "port")) {
+				peer->port = atoi(v->value);
+			} else if (!strcasecmp(v->name, "ip")) {
+				ast_copy_string(peer->ip, v->value, sizeof(peer->ip));
+			} else if (!strcasecmp(v->name, "outgoinglimit")) {
+				if ((peer->outgoinglimit = atoi(v->value)) < 0) {
+					peer->outgoinglimit = 0;
+				}
+			} else if (!strcasecmp(v->name, "accountcode")) {
+				ast_copy_string(peer->accountcode, v->value, sizeof(peer->accountcode));
+			} else if (!strcasecmp(v->name, "rtptimeout")) {
+				if ((peer->rtptimeout = atoi(v->value)) < 0) {
+					peer->rtptimeout = gRTPTimeout;
+				}
+			} else if (!strcasecmp(v->name, "disallow")) {
+				ast_parse_allow_disallow(&peer->prefs, &peer->capability, 
+												 v->value, 0); 
+			} else if (!strcasecmp(v->name, "allow")) {
+				const char* tcodecs = v->value;
+				if (!strcasecmp(v->value, "all")) {
+					tcodecs = "ulaw,alaw,g729,g723,gsm";
+				}
+				ast_parse_allow_disallow(&peer->prefs, &peer->capability, 
+												 tcodecs, 1);				 
+			} else if (!strcasecmp(v->name,  "amaflags")) {
+				peer->amaflags = ast_cdr_amaflags2int(v->value);
+			} else if (!strcasecmp(v->name, "dtmfmode")) {
+				if (!strcasecmp(v->value, "rfc2833"))
+					peer->dtmfmode = H323_DTMF_RFC2833;
+				else if (!strcasecmp(v->value, "q931keypad"))
+					peer->dtmfmode = H323_DTMF_Q931;
+				else if (!strcasecmp(v->value, "h245alphanumeric"))
+					peer->dtmfmode = H323_DTMF_H245ALPHANUMERIC;
+				else if (!strcasecmp(v->value, "h245signal"))
+					peer->dtmfmode = H323_DTMF_H245SIGNAL;
+			}
+			v = v->next;
+		}
+	}
+
+	if (gH323Debug)
+		ast_verbose("+++   build_peer\n");
+
+	return peer;
+}
+
+static int ooh323_do_reload(void)
+{
+	if (gH323Debug) {
+		ast_verbose("---   ooh323_do_reload\n");
+	}
+
+	reload_config(1);
+
+	if (gH323Debug) {
+		ast_verbose("+++   ooh323_do_reload\n");
+	}
+
+	return 0;
+}
+
+#if 0
+/*--- h323_reload: Force reload of module from cli ---*/
+static int ooh323_reload(int fd, int argc, char *argv[])
+{
+
+	if (gH323Debug)
+		ast_verbose("---   ooh323_reload\n");
+
+	ast_mutex_lock(&h323_reload_lock);
+	if (h323_reloading) {
+		ast_verbose("Previous OOH323 reload not yet done\n");
+	} 
+	else {
+		h323_reloading = 1;
+	}
+	ast_mutex_unlock(&h323_reload_lock);
+	restart_monitor();
+
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_reload\n");
+
+	return 0;
+}
+#endif
+
+#if 0
+static int reload(void *mod)
+{
+	return ooh323_reload(0, 0, NULL);
+}
+#endif
+
+int reload_config(int reload)
+{
+	int format;
+	struct ooAliases  *pNewAlias = NULL;
+	struct ast_config *cfg;
+	struct ast_variable *v;
+	struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
+	struct ooh323_user *user = NULL;
+	struct ooh323_peer *peer = NULL;
+	char *cat;
+	const char *utype;
+
+	if (gH323Debug)
+		ast_verbose("---   reload_config\n");
+
+	cfg = ast_config_load((char*)config, config_flags);
+
+	/* We *must* have a config file otherwise stop immediately */
+	if (!cfg) {
+		ast_log(LOG_NOTICE, "Unable to load config %s, OOH323 disabled\n", config);
+		return 1;
+	} else if (cfg == CONFIG_STATUS_FILEUNCHANGED)
+		return RESULT_SUCCESS;
+
+	if (reload) {
+		delete_users();
+		delete_peers();
+	}
+
+	/* Inintialize everything to default */
+	strcpy(gLogFile, DEFAULT_LOGFILE);
+	gPort = 1720;
+	gIP[0] = '\0';
+	strcpy(gCallerID, DEFAULT_H323ID);
+	gCapability = AST_FORMAT_ULAW;
+	memset(&gPrefs, 0, sizeof(struct ast_codec_pref));
+	gDTMFMode = H323_DTMF_RFC2833;
+	gRasGkMode = RasNoGatekeeper;
+	gGatekeeper[0] = '\0';
+	gRTPTimeout = 60;
+	strcpy(gAccountcode, DEFAULT_H323ACCNT);
+	gFastStart = 1;
+	gTunneling = 1;
+	gTOS = 0;
+	strcpy(gContext, DEFAULT_CONTEXT);
+	gAliasList = NULL;
+	gMediaWaitForConnect = 0;
+	ooconfig.mTCPPortStart = 12030;
+	ooconfig.mTCPPortEnd = 12230;
+
+	v = ast_variable_browse(cfg, "general");
+	while (v) {
+	
+		if (!strcasecmp(v->name, "port")) {
+			gPort = (int)strtol(v->value, NULL, 10);
+		} else if (!strcasecmp(v->name, "bindaddr")) {
+			ast_copy_string(gIP, v->value, sizeof(gIP));
+		} else if (!strcasecmp(v->name, "h225portrange")) {
+			char* endlimit = 0;
+			char temp[256];
+			ast_copy_string(temp, v->value, sizeof(temp));
+			endlimit = strchr(temp, ',');
+			if (endlimit) {
+				*endlimit = '\0';
+				endlimit++;
+				ooconfig.mTCPPortStart = atoi(temp);
+				ooconfig.mTCPPortEnd = atoi(endlimit);
+
+				if (ooH323EpSetTCPPortRange(ooconfig.mTCPPortStart, 
+													ooconfig.mTCPPortEnd) == OO_FAILED) {
+					ast_log(LOG_ERROR, "h225portrange: Failed to set range\n");
+				}
+			} else {
+				ast_log(LOG_ERROR, "h225portrange: Invalid format, separate port range with \",\"\n");
+			}
+		} else if (!strcasecmp(v->name, "gateway")) {
+			gIsGateway = ast_true(v->value);
+		} else if (!strcasecmp(v->name, "faststart")) {
+			gFastStart = ast_true(v->value);
+			if (gFastStart)
+				ooH323EpEnableFastStart();
+			else
+				ooH323EpDisableFastStart();
+		} else if (!strcasecmp(v->name, "mediawaitforconnect")) {
+			gMediaWaitForConnect = ast_true(v->value);
+			if (gMediaWaitForConnect)
+				ooH323EpEnableMediaWaitForConnect();
+			else 
+				ooH323EpDisableMediaWaitForConnect();
+		} else if (!strcasecmp(v->name, "h245tunneling")) {
+			gTunneling = ast_true(v->value);
+			if (gTunneling)
+				ooH323EpEnableH245Tunneling();
+			else
+				ooH323EpDisableH245Tunneling();
+		} else if (!strcasecmp(v->name, "h323id")) {
+			pNewAlias = malloc(sizeof(*pNewAlias));
+			if (!pNewAlias) {
+				ast_log(LOG_ERROR, "Failed to allocate memory for h323id alias\n");
+				return 1;
+			}
+			pNewAlias->type =  T_H225AliasAddress_h323_ID;
+			pNewAlias->value = strdup(v->value);
+			pNewAlias->next = gAliasList;
+			gAliasList = pNewAlias;
+			pNewAlias = NULL;
+		} else if (!strcasecmp(v->name, "e164")) {
+			pNewAlias = malloc(sizeof(*pNewAlias));
+			if (!pNewAlias) {
+				ast_log(LOG_ERROR, "Failed to allocate memory for e164 alias\n");
+				return 1;
+			}
+			pNewAlias->type =  T_H225AliasAddress_dialedDigits;
+			pNewAlias->value = strdup(v->value);
+			pNewAlias->next = gAliasList;
+			gAliasList = pNewAlias;
+			pNewAlias = NULL;
+		} else if (!strcasecmp(v->name, "email")) {
+			pNewAlias = malloc(sizeof(*pNewAlias));
+			if (!pNewAlias) {
+				ast_log(LOG_ERROR, "Failed to allocate memory for email alias\n");
+				return 1;
+			}
+			pNewAlias->type =  T_H225AliasAddress_email_ID;
+			pNewAlias->value = strdup(v->value);
+			pNewAlias->next = gAliasList;
+			gAliasList = pNewAlias;
+			pNewAlias = NULL;
+		} else if (!strcasecmp(v->name, "callerid")) {
+			ast_copy_string(gCallerID, v->value, sizeof(gCallerID));
+		} else if (!strcasecmp(v->name, "incominglimit")) {
+			gIncomingLimit = atoi(v->value);
+		} else if (!strcasecmp(v->name, "outgoinglimit")) {
+			gOutgoingLimit = atoi(v->value);
+		} else if (!strcasecmp(v->name, "gatekeeper")) {
+			if (!strcasecmp(v->value, "DISABLE")) {
+				gRasGkMode = RasNoGatekeeper;
+			} else if (!strcasecmp(v->value, "DISCOVER")) {
+				gRasGkMode = RasDiscoverGatekeeper;
+			} else {
+				gRasGkMode = RasUseSpecificGatekeeper;
+				ast_copy_string(gGatekeeper, v->value, sizeof(gGatekeeper));
+			}
+		} else if (!strcasecmp(v->name, "logfile")) {
+			ast_copy_string(gLogFile, v->value, sizeof(gLogFile));
+		} else if (!strcasecmp(v->name, "context")) {
+			ast_copy_string(gContext, v->value, sizeof(gContext));
+			ast_verb(3, "  == Setting default context to %s\n", gContext);
+		} else if (!strcasecmp(v->name, "rtptimeout")) {
+			gRTPTimeout = atoi(v->value);
+			if (gRTPTimeout <= 0)
+				gRTPTimeout = 60;
+		} else if (!strcasecmp(v->name, "tos")) {
+			if (sscanf(v->value, "%i", &format) == 1)
+				gTOS = format & 0xff;
+			else if (!strcasecmp(v->value, "lowdelay"))
+				gTOS = IPTOS_LOWDELAY;
+			else if (!strcasecmp(v->value, "throughput"))
+				gTOS = IPTOS_THROUGHPUT;
+			else if (!strcasecmp(v->value, "reliability"))
+				gTOS = IPTOS_RELIABILITY;
+			else if (!strcasecmp(v->value, "mincost"))
+				gTOS = IPTOS_MINCOST;
+			else if (!strcasecmp(v->value, "none"))
+				gTOS = 0;
+			else
+				ast_log(LOG_WARNING, "Invalid tos value at line %d, should be "
+											"'lowdelay', 'throughput', 'reliability', "
+											"'mincost', or 'none'\n", v->lineno);
+		} else if (!strcasecmp(v->name, "amaflags")) {
+			gAMAFLAGS = ast_cdr_amaflags2int(v->value);
+		} else if (!strcasecmp(v->name, "accountcode")) {
+			ast_copy_string(gAccountcode, v->value, sizeof(gAccountcode)-1);
+		} else if (!strcasecmp(v->name, "disallow")) {
+			ast_parse_allow_disallow(&gPrefs, &gCapability, v->value, 0);
+		} else if (!strcasecmp(v->name, "allow")) {
+			const char* tcodecs = v->value;
+			if (!strcasecmp(v->value, "all")) {
+				tcodecs = "ulaw,alaw,g729,g723,gsm";
+			}
+			ast_parse_allow_disallow(&gPrefs, &gCapability, tcodecs, 1);
+		} else if (!strcasecmp(v->name, "dtmfmode")) {
+			if (!strcasecmp(v->value, "inband"))
+				gDTMFMode = H323_DTMF_INBAND;
+			else if (!strcasecmp(v->value, "rfc2833"))
+				gDTMFMode = H323_DTMF_RFC2833;
+			else if (!strcasecmp(v->value, "q931keypad"))
+				gDTMFMode = H323_DTMF_Q931;
+			else if (!strcasecmp(v->value, "h245alphanumeric"))
+				gDTMFMode = H323_DTMF_H245ALPHANUMERIC;
+			else if (!strcasecmp(v->value, "h245signal"))
+				gDTMFMode = H323_DTMF_H245SIGNAL;
+			else {
+				ast_log(LOG_WARNING, "Unknown dtmf mode '%s', using rfc2833\n", v->value);
+				gDTMFMode = H323_DTMF_RFC2833;
+			}
+		}  
+		v = v->next;
+	}
+	
+	for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) {
+		if (strcasecmp(cat, "general")) {
+			int friend_type = 0;
+			utype = ast_variable_retrieve(cfg, cat, "type");
+			if (utype) {
+				friend_type = strcasecmp(utype, "friend");
+				if (!strcmp(utype, "user") || 0 == friend_type) {
+					user = build_user(cat, ast_variable_browse(cfg, cat));
+					if (user) {
+						ast_mutex_lock(&userl.lock);
+						user->next = userl.users;
+						userl.users = user;
+						ast_mutex_unlock(&userl.lock);
+					} else {
+						ast_log(LOG_WARNING, "Failed to build user %s\n", cat);
+					}
+				}
+				if (!strcasecmp(utype, "peer") || 0 == friend_type) {
+					peer = build_peer(cat, ast_variable_browse(cfg, cat), friend_type);
+					if (peer) {
+						ast_mutex_lock(&peerl.lock);
+						peer->next = peerl.peers;
+						peerl.peers = peer;
+						ast_mutex_unlock(&peerl.lock);
+					} else {
+						ast_log(LOG_WARNING, "Failed to build peer %s\n", cat);
+					}
+				}
+			}
+		}
+	}
+	ast_config_destroy(cfg);
+
+
+	/* Determine ip address if neccessary */
+	if (ast_strlen_zero(gIP)) {
+		ooGetLocalIPAddress(gIP);
+		if (!strcmp(gIP, "127.0.0.1")) {
+			ast_log(LOG_NOTICE, "Failed to determine local ip address. Please "
+									 "specify it in ooh323.conf. OOH323 Disabled\n");
+			return 1;
+		}
+	}
+
+	if (gH323Debug)
+		ast_verbose("+++   reload_config\n");
+
+	return 0;
+}
+
+static char *handle_cli_ooh323_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	char ip_port[30];
+	struct ooh323_peer *prev = NULL, *peer = NULL;
+	
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "ooh323 show peer";
+		e->usage =
+			"Usage: ooh323 show peer <name>\n"
+			"		 List details of specific OOH323 peer.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 4)
+		return CLI_SHOWUSAGE;
+
+	ast_mutex_lock(&peerl.lock);
+	peer = peerl.peers;
+	while (peer) {
+		ast_mutex_lock(&peer->lock);
+		if (!strcmp(peer->name, a->argv[3]))
+			break;
+		else {
+			prev = peer;
+			peer = peer->next;
+			ast_mutex_unlock(&prev->lock);
+		}
+	}
+
+	if (peer) {
+		snprintf(ip_port, sizeof(ip_port), "%s:%d", peer->ip, peer->port);
+		ast_cli(a->fd, "%-15.15s%s\n", "Name: ", peer->name);
+		ast_cli(a->fd, "%-15.15s%s", "Format Prefs: ", "(");
+		print_codec_to_cli(a->fd, &peer->prefs);
+		ast_cli(a->fd, ")\n");
+		ast_cli(a->fd, "%-15.15s", "DTMF Mode: ");
+		if (peer->dtmfmode & H323_DTMF_RFC2833)
+			ast_cli(a->fd, "%s\n", "rfc2833");
+		else if (peer->dtmfmode & H323_DTMF_Q931)
+			ast_cli(a->fd, "%s\n", "q931keypad");
+		else if (peer->dtmfmode & H323_DTMF_H245ALPHANUMERIC)
+			ast_cli(a->fd, "%s\n", "h245alphanumeric");
+		else if (peer->dtmfmode & H323_DTMF_H245SIGNAL)
+			ast_cli(a->fd, "%s\n", "h245signal");
+		else
+			ast_cli(a->fd, "%s\n", "unknown");
+		ast_cli(a->fd, "%-15.15s%s\n", "AccountCode: ", peer->accountcode);
+		ast_cli(a->fd, "%-15.15s%s\n", "AMA flags: ",
+		ast_cdr_flags2str(peer->amaflags));
+		ast_cli(a->fd, "%-15.15s%s\n", "Ip:Port: ", ip_port);
+		ast_cli(a->fd, "%-15.15s%d\n", "OutgoingLimit: ", peer->outgoinglimit);
+		ast_cli(a->fd, "%-15.15s%d\n", "rtptimeout: ", peer->rtptimeout);
+		ast_mutex_unlock(&peer->lock);
+	} else {
+		ast_cli(a->fd, "Peer %s not found\n", a->argv[3]);
+		ast_cli(a->fd, "\n");
+	}
+	ast_mutex_unlock(&peerl.lock);
+
+	return CLI_SUCCESS;
+}
+
+static char *handle_cli_ooh323_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	char ip_port[30];
+	char formats[512];
+	struct ooh323_peer *prev = NULL, *peer = NULL;
+
+#define FORMAT  "%-15.15s  %-15.15s  %-23.23s  %-s\n"
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "ooh323 show peers";
+		e->usage =
+			"Usage: ooh323 show peers\n"
+			"		 Lists all known OOH323 peers.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 3)
+		return CLI_SHOWUSAGE;
+
+	ast_cli(a->fd, FORMAT, "Name", "Accountcode", "ip:port", "Formats");
+
+	ast_mutex_lock(&peerl.lock);
+	peer = peerl.peers;
+	while (peer) {
+		ast_mutex_lock(&peer->lock);
+		snprintf(ip_port, sizeof(ip_port), "%s:%d", peer->ip, peer->port);
+		ast_cli(a->fd, FORMAT, peer->name,
+					peer->accountcode,
+					ip_port,
+					ast_getformatname_multiple(formats, sizeof(formats), peer->capability));
+		prev = peer;
+		peer = peer->next;
+		ast_mutex_unlock(&prev->lock);
+	}
+	ast_mutex_unlock(&peerl.lock);
+
+#undef FORMAT
+
+	return CLI_SUCCESS;
+}
+
+/*! \brief Print codec list from preference to CLI/manager */
+static void print_codec_to_cli(int fd, struct ast_codec_pref *pref)
+{
+	int x, codec;
+
+	for (x = 0; x < 32; x++) {
+		codec = ast_codec_pref_index(pref, x);
+		if (!codec)
+			break;
+		ast_cli(fd, "%s", ast_getformatname(codec));
+		ast_cli(fd, ":%d", pref->framing[x]);
+		if (x < 31 && ast_codec_pref_index(pref, x + 1))
+			ast_cli(fd, ",");
+	}
+	if (!x)
+		ast_cli(fd, "none");
+}
+
+static char *handle_cli_ooh323_show_user(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	struct ooh323_user *prev = NULL, *user = NULL;
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "ooh323 show user";
+		e->usage =
+			"Usage: ooh323 show user <name>\n"
+			"		 List details of specific OOH323 user.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 4)
+		return CLI_SHOWUSAGE;
+
+	ast_mutex_lock(&userl.lock);
+	user = userl.users;
+	while (user) {
+		ast_mutex_lock(&user->lock);
+		if (!strcmp(user->name, a->argv[3]))
+			break;
+		else {
+			prev = user;
+			user = user->next;
+			ast_mutex_unlock(&prev->lock);
+		}
+	}
+
+	if (user) {
+		ast_cli(a->fd, "%-15.15s%s\n", "Name: ", user->name);
+		ast_cli(a->fd, "%-15.15s%s", "Format Prefs: ", "(");
+		print_codec_to_cli(a->fd, &user->prefs);
+		ast_cli(a->fd, ")\n");
+		ast_cli(a->fd, "%-15.15s", "DTMF Mode: ");
+		if (user->dtmfmode & H323_DTMF_RFC2833)
+			ast_cli(a->fd, "%s\n", "rfc2833");
+		else if (user->dtmfmode & H323_DTMF_Q931)
+			ast_cli(a->fd, "%s\n", "q931keypad");
+		else if (user->dtmfmode & H323_DTMF_H245ALPHANUMERIC)
+			ast_cli(a->fd, "%s\n", "h245alphanumeric");
+		else if (user->dtmfmode & H323_DTMF_H245SIGNAL)
+			ast_cli(a->fd, "%s\n", "h245signal");
+		else
+			ast_cli(a->fd, "%s\n", "unknown");
+		ast_cli(a->fd, "%-15.15s%s\n", "AccountCode: ", user->accountcode);
+		ast_cli(a->fd, "%-15.15s%s\n", "AMA flags: ", ast_cdr_flags2str(user->amaflags));
+		ast_cli(a->fd, "%-15.15s%s\n", "Context: ", user->context);
+		ast_cli(a->fd, "%-15.15s%d\n", "IncomingLimit: ", user->incominglimit);
+		ast_cli(a->fd, "%-15.15s%d\n", "rtptimeout: ", user->rtptimeout);
+		ast_mutex_unlock(&user->lock);
+	} else {
+		ast_cli(a->fd, "User %s not found\n", a->argv[3]);
+		ast_cli(a->fd, "\n");
+	}
+	ast_mutex_unlock(&userl.lock);
+
+	return CLI_SUCCESS;
+}
+
+static char *handle_cli_ooh323_show_users(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	char formats[512];
+	struct ooh323_user *prev = NULL, *user = NULL;
+
+#define FORMAT1  "%-15.15s  %-15.15s  %-15.15s  %-s\n"
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "ooh323 show users";
+		e->usage =
+			"Usage: ooh323 show users \n"
+			"		 Lists all known OOH323 users.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 3)
+		return CLI_SHOWUSAGE;
+
+	ast_cli(a->fd, FORMAT1, "Username", "Accountcode", "Context", "Formats");
+
+	ast_mutex_lock(&userl.lock);
+	user = userl.users;
+	while (user) {
+		ast_mutex_lock(&user->lock);
+		ast_cli(a->fd, FORMAT1, user->name,
+					user->accountcode, user->context,
+					ast_getformatname_multiple(formats, 512, user->capability));
+		prev = user;
+		user = user->next;
+		ast_mutex_unlock(&prev->lock);
+	}
+	ast_mutex_unlock(&userl.lock);
+
+#undef FORMAT1
+
+	return CLI_SUCCESS;
+}
+
+static char *handle_cli_ooh323_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "ooh323 set debug [off]";
+		e->usage =
+			"Usage: ooh323 set debug [off]\n"
+			"		 Enables/Disables debugging of OOH323 channel driver\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc < 3 || a->argc > 4)
+		return CLI_SHOWUSAGE;
+	if (a->argc == 4 && strcasecmp(a->argv[3], "off"))
+		return CLI_SHOWUSAGE;
+
+	gH323Debug = (a->argc == 4) ? FALSE : TRUE;
+	ast_cli(a->fd, "OOH323 Debugging %s\n", gH323Debug ? "Enabled" : "Disabled");
+
+	return CLI_SUCCESS;
+}
+
+#if 0
+static int ooh323_show_channels(int fd, int argc, char *argv[])
+{
+	return RESULT_SUCCESS;
+}
+#endif
+
+static char *handle_cli_ooh323_show_config(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	char value[512];
+	ooAliases *pAlias = NULL, *pAliasNext = NULL;;
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "ooh323 show config";
+		e->usage =
+			"Usage: ooh323 show config\n"
+			"		 Shows global configuration of H.323 channel driver\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 3)
+		return CLI_SHOWUSAGE;
+
+	snprintf(value, sizeof(value), "%s:%d", gIP, gPort);
+	ast_cli(a->fd, "\nObjective Open H.323 Channel Driver's Config:\n");
+	ast_cli(a->fd, "%-20s%s\n", "IP:Port: ", value);
+	ast_cli(a->fd, "%-20s%s\n", "FastStart", gFastStart?"yes":"no");
+	ast_cli(a->fd, "%-20s%s\n", "Tunneling", gTunneling?"yes":"no");
+	ast_cli(a->fd, "%-20s%s\n", "CallerId", gCallerID);
+	ast_cli(a->fd, "%-20s%s\n", "MediaWaitForConnect", gMediaWaitForConnect ? "yes" : "no");
+
+#if 0
+	{
+		extern OOH323EndPoint gH323ep;
+
+		ast_cli(a->fd, "%-20s%s\n", "FASTSTART",
+			(OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART) != 0) ? "yes" : "no");
+		ast_cli(a->fd, "%-20s%s\n", "TUNNELING",
+			(OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING) != 0) ? "yes" : "no");
+		ast_cli(a->fd, "%-20s%s\n", "MEDIAWAITFORCONN",
+			(OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN) != 0) ? "yes" : "no");
+	}
+#endif
+
+	if (gRasGkMode == RasNoGatekeeper)
+		snprintf(value, sizeof(value), "%s", "No Gatekeeper");
+	else if (gRasGkMode == RasDiscoverGatekeeper)
+		snprintf(value, sizeof(value), "%s", "Discover");
+	else
+		snprintf(value, sizeof(value), "%s", gGatekeeper);
+
+	ast_cli(a->fd, "%-20s%s\n", "Gatekeeper:", value);
+	ast_cli(a->fd, "%-20s%s\n", "H.323 LogFile:", gLogFile);
+	ast_cli(a->fd, "%-20s%s\n", "Context:", gContext);
+	ast_cli(a->fd, "%-20s%s\n", "Capability:", ast_getformatname_multiple(value, sizeof(value), gCapability));
+	ast_cli(a->fd, "%-20s", "DTMF Mode: ");
+	if (gDTMFMode & H323_DTMF_RFC2833)
+		ast_cli(a->fd, "%s\n", "rfc2833");
+	else if (gDTMFMode & H323_DTMF_Q931)
+		ast_cli(a->fd, "%s\n", "q931keypad");
+	else if (gDTMFMode & H323_DTMF_H245ALPHANUMERIC)
+		ast_cli(a->fd, "%s\n", "h245alphanumeric");
+	else if (gDTMFMode & H323_DTMF_H245SIGNAL)
+		ast_cli(a->fd, "%s\n", "h245signal");
+	else
+		ast_cli(a->fd, "%s\n", "unknown");
+	ast_cli(a->fd, "%-20s%s\n", "AccountCode: ", gAccountcode);
+	ast_cli(a->fd, "%-20s%s\n", "AMA flags: ", ast_cdr_flags2str(gAMAFLAGS));
+
+	pAlias = gAliasList;
+	if (pAlias)
+		ast_cli(a->fd, "%-20s\n", "Aliases: ");
+	while (pAlias) {
+		pAliasNext = pAlias->next;
+		if (pAliasNext) {
+			ast_cli(a->fd, "\t%-30s\t%-30s\n", pAlias->value, pAliasNext->value);
+			pAlias = pAliasNext->next;
+		} else {
+			ast_cli(a->fd, "\t%-30s\n", pAlias->value);
+			pAlias = pAlias->next;
+		}
+	}
+
+	return CLI_SUCCESS;
+}
+
+static struct ast_cli_entry cli_ooh323[] = {
+	AST_CLI_DEFINE(handle_cli_ooh323_set_debug,	"Enable/Disable OOH323 debugging"),
+	AST_CLI_DEFINE(handle_cli_ooh323_show_config, "Show details on global configuration of H.323 channel driver"),
+	AST_CLI_DEFINE(handle_cli_ooh323_show_peer,	"Show details on specific OOH323 peer"),
+	AST_CLI_DEFINE(handle_cli_ooh323_show_peers,  "Show defined OOH323 peers"),
+	AST_CLI_DEFINE(handle_cli_ooh323_show_user,	"Show details on specific OOH323 user"),
+	AST_CLI_DEFINE(handle_cli_ooh323_show_users,  "Show defined OOH323 users"),
+};
+
+static int load_module(void)
+{
+	int res;
+	struct ooAliases * pNewAlias = NULL;
+	struct ooh323_peer *peer = NULL;
+	OOH225MsgCallbacks h225Callbacks = {0, 0, 0, 0};
+
+	OOH323CALLBACKS h323Callbacks = {
+		.onNewCallCreated = onNewCallCreated,
+		.onAlerting = onAlerting,
+		.onIncomingCall = NULL,
+		.onOutgoingCall = NULL,
+		.onCallEstablished = onCallEstablished,
+		.onCallCleared = onCallCleared,
+		.openLogicalChannels = NULL,
+		.onReceivedDTMF = &ooh323_onReceivedDigit
+	};
+
+	ast_log(LOG_NOTICE, 
+		"---------------------------------------------------------------------------------\n"
+		"---  ******* IMPORTANT NOTE ***********\n"
+		"---\n"
+		"---  This module is currently unsupported.  Use it at your own risk.\n"
+		"---\n"
+		"---------------------------------------------------------------------------------\n");
+
+	h225Callbacks.onReceivedSetup = &ooh323_onReceivedSetup;
+
+	userl.users = NULL;
+	ast_mutex_init(&userl.lock);
+	peerl.peers = NULL;
+	ast_mutex_init(&peerl.lock);
+ 
+#if 0		
+	ast_register_atexit(&ast_ooh323c_exit);
+#endif
+
+	if (!(sched = sched_context_create())) {
+		ast_log(LOG_WARNING, "Unable to create schedule context\n");
+	}
+	if (!(io = io_context_create())) {
+		ast_log(LOG_WARNING, "Unable to create I/O context\n");
+	}
+
+
+	if (!(res = reload_config(0))) {
+		/* Make sure we can register our OOH323 channel type */
+		if (ast_channel_register(&ooh323_tech)) {
+			ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
+			return 0;
+		}
+		ast_rtp_proto_register(&ooh323_rtp);
+		ast_cli_register_multiple(cli_ooh323, sizeof(cli_ooh323) / sizeof(struct ast_cli_entry));
+
+		 /* fire up the H.323 Endpoint */		 
+		if (OO_OK != ooH323EpInitialize(OO_CALLMODE_AUDIOCALL, gLogFile)) {
+			ast_log(LOG_ERROR, "Failed to initialize OOH323 endpoint-OOH323 Disabled\n");
+			return 1;
+		}
+
+		if (gIsGateway)
+			ooH323EpSetAsGateway();
+
+		ooH323EpDisableAutoAnswer();
+		ooH323EpSetH225MsgCallbacks(h225Callbacks);
+		ooH323EpSetTraceLevel(OOTRCLVLDBGC);
+		ooH323EpSetLocalAddress(gIP, gPort);
+		ooH323EpSetCallerID(gCallerID);
+ 
+		/* Set aliases if any */
+		for (pNewAlias = gAliasList; pNewAlias; pNewAlias = pNewAlias->next) {
+			switch (pNewAlias->type) {
+			case T_H225AliasAddress_h323_ID:
+				ooH323EpAddAliasH323ID(pNewAlias->value);
+				break;
+			case T_H225AliasAddress_dialedDigits:	
+				ooH323EpAddAliasDialedDigits(pNewAlias->value);
+				break;
+			case T_H225AliasAddress_email_ID:	
+				ooH323EpAddAliasEmailID(pNewAlias->value);
+				break;
+			}
+		}
+
+		ast_mutex_lock(&peerl.lock);
+		peer = peerl.peers;
+		while (peer) {
+			if (peer->h323id)
+				ooH323EpAddAliasH323ID(peer->h323id);
+			if (peer->email)
+				ooH323EpAddAliasEmailID(peer->email);
+			if (peer->e164)
+				ooH323EpAddAliasDialedDigits(peer->e164);
+			if (peer->url)
+				ooH323EpAddAliasURLID(peer->url);
+			peer = peer->next;
+		}
+		ast_mutex_unlock(&peerl.lock);
+	
+
+		if (gMediaWaitForConnect)
+			ooH323EpEnableMediaWaitForConnect();
+		else 
+			ooH323EpDisableMediaWaitForConnect();
+
+		/* Fast start and tunneling options */
+		if (gFastStart)
+			ooH323EpEnableFastStart();
+		else
+			ooH323EpDisableFastStart();
+
+		if (!gTunneling)
+			ooH323EpDisableH245Tunneling();
+
+		/* Gatekeeper */
+		if (gRasGkMode == RasUseSpecificGatekeeper)
+			ooGkClientInit(gRasGkMode, gGatekeeper, 0);
+		else if (gRasGkMode == RasDiscoverGatekeeper)
+			ooGkClientInit(gRasGkMode, 0, 0);
+
+		/* Register callbacks */
+		ooH323EpSetH323Callbacks(h323Callbacks);
+
+		/* Add endpoint capabilities */
+		if (ooh323c_set_capability(&gPrefs, gCapability, gDTMFMode) < 0) {
+			ast_log(LOG_ERROR, "Capabilities failure for OOH323. OOH323 Disabled.\n");
+			return 1;
+		}
+  
+
+		/* Create H.323 listener */
+		if (ooCreateH323Listener() != OO_OK) {
+			ast_log(LOG_ERROR, "OOH323 Listener Creation failure. OOH323 DISABLED\n");
+		
+			ooH323EpDestroy();
+			return 1;
+		}
+
+		if (ooh323c_start_stack_thread() < 0) {
+			ast_log(LOG_ERROR, "Failed to start OOH323 stack thread. OOH323 DISABLED\n");
+			ooH323EpDestroy();
+			return 1;
+		}
+		/* And start the monitor for the first time */
+		restart_monitor();
+	}
+
+	return 0;
+}
+
+
+static void *do_monitor(void *data)
+{
+	int res;
+	int reloading;
+	struct ooh323_pvt *h323 = NULL;
+	time_t t;
+
+	for (;;) {
+		struct ooh323_pvt *h323_next;
+		/* Check for a reload request */
+		ast_mutex_lock(&h323_reload_lock);
+		reloading = h323_reloading;
+		h323_reloading = 0;
+		ast_mutex_unlock(&h323_reload_lock);
+		if (reloading) {
+			ast_verb(1, "Reloading H.323\n");
+			ooh323_do_reload();
+		}
+		/* Check for interfaces needing to be killed */
+		ast_mutex_lock(&iflock);
+		time(&t);
+		h323 = iflist;
+		while (h323) {
+			h323_next = h323->next;
+
+			/* TODO: Need to add rtptimeout keepalive support */
+			if (ast_test_flag(h323, H323_NEEDDESTROY)) {
+				ooh323_destroy (h323);
+			}
+			h323 = h323_next;
+		}
+		ast_mutex_unlock(&iflock);
+		pthread_testcancel();
+		/* Wait for sched or io */
+		res = ast_sched_wait(sched);
+		if ((res < 0) || (res > 1000)) {
+			res = 1000;
+		}
+		res = ast_io_wait(io, res);
+		pthread_testcancel();
+		ast_mutex_lock(&monlock);
+		if (res >= 0) {
+			ast_sched_runq(sched);
+		}
+		ast_mutex_unlock(&monlock);
+	}
+	/* Never reached */
+	return NULL;
+}
+
+int restart_monitor(void)
+{
+	pthread_attr_t attr;
+
+	/* If we're supposed to be stopped -- stay stopped */
+	if (monitor_thread == AST_PTHREADT_STOP)
+		return 0;
+	if (ast_mutex_lock(&monlock)) {
+		ast_log(LOG_WARNING, "Unable to lock monitor\n");
+		return -1;
+	}
+	if (monitor_thread == pthread_self()) {
+		ast_mutex_unlock(&monlock);
+		ast_log(LOG_WARNING, "Cannot kill myself\n");
+		return -1;
+	}
+	if (monitor_thread != AST_PTHREADT_NULL) {
+		/* Wake up the thread */
+		pthread_kill(monitor_thread, SIGURG);
+	} else {
+		pthread_attr_init(&attr);
+		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+		/* Start a new monitor */
+		if (ast_pthread_create(&monitor_thread, &attr, do_monitor, NULL) < 0) {
+			ast_mutex_unlock(&monlock);
+			ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
+			return -1;
+		}
+	}
+	ast_mutex_unlock(&monlock);
+	return 0;
+}
+
+
+
+int ooh323_destroy(struct ooh323_pvt *p)
+{
+	/* NOTE: Assumes iflock already acquired */
+	struct ooh323_pvt *prev = NULL, *cur = NULL;
+
+
+	if (gH323Debug) {
+		ast_verbose("---   ooh323_destroy \n");
+
+		if (p)
+			ast_verbose(" Destroying %s\n", p->username);
+	}
+
+	cur = iflist;
+	while (cur) {
+		if (cur == p) { break; }
+		prev = cur;
+		cur = cur->next;
+	}
+
+	if (cur) {
+		ast_mutex_lock(&cur->lock);
+		if (prev)
+			prev->next = cur->next;
+		else
+			iflist = cur->next;
+
+		if (cur->callToken) {
+			free(cur->callToken);
+			cur->callToken = 0;
+		}
+
+		if (cur->username) {
+			free(cur->username);
+			cur->username = 0;
+		}
+
+		if (cur->host) {
+			free(cur->host);
+			cur->host = 0;
+		}
+
+		if (cur->callerid_name) {
+			free(cur->callerid_name);
+			cur->callerid_name = 0;
+		}
+		
+		if (cur->callerid_num) {
+			free(cur->callerid_num);
+			cur->callerid_num = 0;
+		}
+
+
+		if (cur->rtp) {
+			ast_rtp_destroy(cur->rtp);
+			cur->rtp = 0;
+		}
+	
+		/* Unlink us from the owner if we have one */
+		if (cur->owner) {
+			ast_channel_lock(cur->owner);
+			ast_debug(1, "Detaching from %s\n", cur->owner->name);
+			cur->owner->tech_pvt = NULL;
+			ast_channel_unlock(cur->owner);
+			cur->owner = NULL;
+		}
+  
+		if (cur->vad) {
+			ast_dsp_free(cur->vad);
+			cur->vad = NULL;
+		}
+		ast_mutex_unlock(&cur->lock);
+		ast_mutex_destroy(&cur->lock);
+
+		free(cur);
+	}
+
+	if (gH323Debug)
+		ast_verbose("+++   ooh323_destroy\n");
+
+	return 0;
+}
+
+int delete_peers()
+{
+	struct ooh323_peer *cur = NULL, *prev = NULL;
+	ast_mutex_lock(&peerl.lock);
+	cur = peerl.peers;
+	while (cur) {
+		prev = cur;
+		cur = cur->next;
+
+		ast_mutex_destroy(&prev->lock);
+		if (prev->h323id)
+			free(prev->h323id);
+		if (prev->email)
+			free(prev->email);
+		if (prev->url)
+			free(prev->url);
+		if (prev->e164)
+			free(prev->e164);
+		free(prev);
+
+		if (cur == peerl.peers) {
+			break;
+		}
+	}
+	peerl.peers = NULL;
+	ast_mutex_unlock(&peerl.lock);
+	return 0;
+}
+
+int delete_users()
+{
+	struct ooh323_user *cur = NULL, *prev = NULL;
+	ast_mutex_lock(&userl.lock);
+	cur = userl.users;
+	while (cur) {
+		prev = cur;
+		cur = cur->next;
+		ast_mutex_destroy(&prev->lock);
+		free(prev);
+		if (cur == userl.users) {
+			break;
+		}
+	}
+	userl.users = NULL;
+	ast_mutex_unlock(&userl.lock);
+	return 0;
+}
+  
+static int unload_module(void)
+{
+	struct ooh323_pvt *p;
+	struct ooAliases *cur = NULL, *prev = NULL;
+
+	if (gH323Debug) {
+		ast_verbose("--- ooh323  unload_module \n");
+	}
+	/* First, take us out of the channel loop */
+	ast_cli_unregister_multiple(cli_ooh323, sizeof(cli_ooh323) / sizeof(struct ast_cli_entry));
+	ast_rtp_proto_unregister(&ooh323_rtp);
+	ast_channel_unregister(&ooh323_tech);
+
+#if 0
+	ast_unregister_atexit(&ast_ooh323c_exit);
+#endif
+
+	if (gH323Debug) {
+		ast_verbose("  unload_module - hanging up all interfaces\n");
+	}
+	if (!ast_mutex_lock(&iflock)) {
+		/* Hangup all interfaces if they have an owner */
+		p = iflist;
+		while (p) {
+			if (p->owner) {
+				ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
+			}
+			p = p->next;
+		}
+		iflist = NULL;
+		ast_mutex_unlock(&iflock);
+	} else {
+		ast_log(LOG_WARNING, "Unable to lock the interface list\n");
+		return -1;
+	}
+
+
+	if (gH323Debug) {
+		ast_verbose("  unload_module - stopping monitor thread\n");
+	}  
+	if (monitor_thread != AST_PTHREADT_NULL) {
+		if (!ast_mutex_lock(&monlock)) {
+			if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP)) {
+				pthread_cancel(monitor_thread);
+				pthread_kill(monitor_thread, SIGURG);
+				pthread_join(monitor_thread, NULL);
+			}
+			monitor_thread = AST_PTHREADT_STOP;
+			ast_mutex_unlock(&monlock);
+		} else {
+			ast_log(LOG_WARNING, "Unable to lock the monitor\n");
+			return -1;
+		}
+	}
+
+
+	if (gH323Debug) {
+		ast_verbose("   unload_module - stopping stack thread\n");
+	}
+	ooh323c_stop_stack_thread();
+
+
+	if (gH323Debug) {
+		ast_verbose("   unload_module - freeing up memory used by interfaces\n");
+	}
+	if (!ast_mutex_lock(&iflock)) {
+		struct ooh323_pvt *pl;
+
+		/* Destroy all the interfaces and free their memory */
+		p = iflist;
+		while (p) {
+			pl = p;
+			p = p->next;
+			/* Free associated memory */
+			ooh323_destroy(pl);
+		}
+		iflist = NULL;
+		ast_mutex_unlock(&iflock);
+	} else {
+		ast_log(LOG_WARNING, "Unable to lock the interface list\n");
+		return -1;
+	}
+ 
+
+	if (gH323Debug) {
+		ast_verbose("  unload_module - deleting users\n");
+	}
+	delete_users();
+
+
+	if (gH323Debug) {
+		ast_verbose("  unload_module - deleting peers\n");
+	}
+	delete_peers();
+
+
+	if (gH323Debug) {
+		ast_verbose("  unload_module - Freeing up alias list\n");
+	}
+	cur = gAliasList;
+	while (cur) {
+	  prev = cur;
+	  cur = cur->next;
+	  free(prev->value);
+	  free(prev);
+	}
+	gAliasList = NULL;
+
+
+	if (gH323Debug) {
+		ast_verbose("	unload_module- destroying OOH323 endpoint \n");
+	}
+	ooH323EpDestroy();
+
+	if (gH323Debug) {
+		ast_verbose("+++ ooh323  unload_module \n");	
+	}
+
+	return 0;
+}
+
+
+
+static enum ast_rtp_get_result ooh323_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
+{
+	struct ooh323_pvt *p = NULL;
+	enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
+
+	if (!(p = (struct ooh323_pvt *) chan->tech_pvt))
+	return AST_RTP_GET_FAILED;
+
+	*rtp = p->rtp;
+
+	if (!(p->rtp)) {
+		return AST_RTP_GET_FAILED;
+	}
+	res = AST_RTP_TRY_NATIVE;
+
+	return res;
+}
+
+static enum ast_rtp_get_result ooh323_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
+{
+	struct ooh323_pvt *p = NULL;
+	enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
+
+	if (!(p = (struct ooh323_pvt *) chan->tech_pvt))
+		return AST_RTP_GET_FAILED;
+
+	*rtp = p->vrtp;
+
+	if (!(p->rtp)) {
+		return AST_RTP_GET_FAILED;
+	}
+	res = AST_RTP_TRY_NATIVE;
+
+	return res;
+}
+
+
+int ooh323_update_capPrefsOrderForCall
+	(ooCallData *call, struct ast_codec_pref *prefs)
+{
+	int i = 0;
+	int codec = ast_codec_pref_index(prefs, i);
+
+	ooResetCapPrefs(call);
+	while (codec) {
+		ooAppendCapToCapPrefs(call, ooh323_convertAsteriskCapToH323Cap(codec));
+		codec = ast_codec_pref_index(prefs, ++i);
+	}
+
+	return 0;
+}
+
+
+int ooh323_convertAsteriskCapToH323Cap(int cap)
+{
+	char formats[512];
+	switch (cap) {
+	case AST_FORMAT_ULAW:
+		return OO_G711ULAW64K;
+	case AST_FORMAT_ALAW:
+		return OO_G711ALAW64K;
+	case AST_FORMAT_GSM:
+		return OO_GSMFULLRATE;
+	case AST_FORMAT_G729A:
+		return OO_G729A;
+	case AST_FORMAT_G723_1:
+		return OO_G7231;
+	case AST_FORMAT_H263:
+		return OO_H263VIDEO;
+	default:
+		ast_log(LOG_NOTICE, "Don't know how to deal with mode %s\n", 
+							ast_getformatname_multiple(formats, sizeof(formats), cap));
+		return -1;
+	}
+}
+
+static int ooh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp,
+	 struct ast_rtp *vrtp, struct ast_rtp *trtp, int codecs, int nat_active)
+{
+	/* XXX Deal with Video */
+	struct ooh323_pvt *p;
+	struct sockaddr_in them;
+	struct sockaddr_in us;
+	int mode;
+
+	if (gH323Debug)
+		ast_verbose("---   ooh323_set_peer - %s\n", chan->name);
+
+	if (!rtp) {
+		return 0;
+	}
+
+	mode = ooh323_convertAsteriskCapToH323Cap(chan->writeformat); 
+	p = (struct ooh323_pvt *) chan->tech_pvt;
+	if (!p) {
+		ast_log(LOG_ERROR, "No Private Structure, this is bad\n");
+		return -1;
+	}
+	ast_rtp_get_peer(rtp, &them);
+	ast_rtp_get_us(rtp, &us);
+	return 0;
+}
+
+
+
+
+int configure_local_rtp(struct ooh323_pvt *p, ooCallData *call)
+{
+	struct sockaddr_in us;
+	ooMediaInfo mediaInfo;
+	int x, format = 0;	  
+
+	if (gH323Debug)
+		ast_verbose("---   configure_local_rtp\n");
+
+	if (p->rtp) {
+		ast_rtp_codec_setpref(p->rtp, &p->prefs);
+	}
+
+	/* figure out our local RTP port and tell the H.323 stack about it*/
+	ast_rtp_get_us(p->rtp, &us);
+
+	ast_copy_string(mediaInfo.lMediaIP, ast_inet_ntoa(us.sin_addr), sizeof(mediaInfo.lMediaIP));
+	mediaInfo.lMediaPort = ntohs(us.sin_port);
+	mediaInfo.lMediaCntrlPort = mediaInfo.lMediaPort +1;
+	for (x = 0; 0 != (format = ast_codec_pref_index(&p->prefs, x)); x++) {
+		strcpy(mediaInfo.dir, "transmit");
+		mediaInfo.cap = ooh323_convertAsteriskCapToH323Cap(format);
+		ooAddMediaInfo(call, mediaInfo);
+		strcpy(mediaInfo.dir, "receive");
+		ooAddMediaInfo(call, mediaInfo);
+		if (mediaInfo.cap == OO_G729A) {
+			strcpy(mediaInfo.dir, "transmit");
+			mediaInfo.cap = OO_G729;
+			ooAddMediaInfo(call, mediaInfo);
+			strcpy(mediaInfo.dir, "receive");
+			ooAddMediaInfo(call, mediaInfo);
+		}
+	}
+
+	if (gH323Debug)
+		ast_verbose("+++   configure_local_rtp\n");
+
+	return 1;
+}
+
+void setup_rtp_connection(ooCallData *call, const char *remoteIp, 
+								  int remotePort)
+{
+	struct ooh323_pvt *p = NULL;
+	struct sockaddr_in them;
+
+	if (gH323Debug)
+		ast_verbose("---   setup_rtp_connection\n");
+
+	/* Find the call or allocate a private structure if call not found */
+	p = find_call(call); 
+
+	if (!p) {
+		ast_log(LOG_ERROR, "Something is wrong: rtp\n");
+		return;
+	}
+
+	them.sin_family = AF_INET;
+	them.sin_addr.s_addr = inet_addr(remoteIp); /* only works for IPv4 */
+	them.sin_port = htons(remotePort);
+	ast_rtp_set_peer(p->rtp, &them);
+
+	if (gH323Debug) {
+		ast_verbose("+++   setup_rtp_connection\n");
+	}
+
+	return;
+}
+
+void close_rtp_connection(ooCallData *call)
+{
+	struct ooh323_pvt *p = NULL;
+
+	if (gH323Debug) {
+		ast_verbose("---   close_rtp_connection\n");
+	}
+
+	p = find_call(call);
+	if (!p) {
+		ast_log(LOG_ERROR, "Couldn't find matching call to close rtp connection\n");
+		return;
+	}
+	ast_mutex_lock(&p->lock);
+	if (p->rtp) {
+		ast_rtp_stop(p->rtp);
+	}
+	ast_mutex_unlock(&p->lock);
+
+	if (gH323Debug) {
+		ast_verbose("+++   close_rtp_connection\n");
+	}
+
+	return;
+}
+
+
+int update_our_aliases(ooCallData *call, struct ooh323_pvt *p)
+{
+	int updated = -1;
+	ooAliases *psAlias = NULL;
+	
+	if (!call->ourAliases)
+		return updated;
+	for (psAlias = call->ourAliases; psAlias; psAlias = psAlias->next) {
+		if (psAlias->type == T_H225AliasAddress_h323_ID) {
+			ast_copy_string(p->callee_h323id, psAlias->value, sizeof(p->callee_h323id));
+			updated = 1;
+		}
+		if (psAlias->type == T_H225AliasAddress_dialedDigits) {
+			ast_copy_string(p->callee_dialedDigits, psAlias->value, sizeof(p->callee_dialedDigits));
+			updated = 1;
+		}
+		if (psAlias->type == T_H225AliasAddress_url_ID) {
+			ast_copy_string(p->callee_url, psAlias->value, sizeof(p->callee_url));
+			updated = 1;
+		}
+		if (psAlias->type == T_H225AliasAddress_email_ID) {
+			ast_copy_string(p->callee_email, psAlias->value, sizeof(p->callee_email));
+			updated = 1;
+		}
+	}
+	return updated;
+}
+
+struct ast_frame *ooh323_rtp_read(struct ast_channel *ast, struct ooh323_pvt *p)
+{
+	/* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
+	struct ast_frame *f;
+	static struct ast_frame null_frame = { AST_FRAME_NULL, };
+	switch (ast->fdno) {
+	case 0:
+		f = ast_rtp_read(p->rtp);	/* RTP Audio */
+		break;
+	case 1:
+		f = ast_rtcp_read(p->rtp);	/* RTCP Control Channel */
+		break;
+	case 2:
+		f = ast_rtp_read(p->vrtp);	/* RTP Video */
+		break;
+	case 3:
+		f = ast_rtcp_read(p->vrtp);	/* RTCP Control Channel for video */
+		break;
+	default:
+		f = &null_frame;
+	}
+	/* Don't send RFC2833 if we're not supposed to */
+	if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & H323_DTMF_RFC2833)) {
+		return &null_frame;
+	}
+	if (p->owner) {
+		/* We already hold the channel lock */
+		if (f->frametype == AST_FRAME_VOICE) {
+			if (f->subclass != p->owner->nativeformats) {
+				ast_debug(1, "Oooh, format changed to %d\n", f->subclass);
+				p->owner->nativeformats = f->subclass;
+				ast_set_read_format(p->owner, p->owner->readformat);
+				ast_set_write_format(p->owner, p->owner->writeformat);
+			}
+			if ((p->dtmfmode & H323_DTMF_INBAND) && p->vad) {
+				f = ast_dsp_process(p->owner, p->vad, f);
+				if (f && (f->frametype == AST_FRAME_DTMF)) {
+					ast_debug(1, "* Detected inband DTMF '%c'\n", f->subclass);
+				}
+			}
+		}
+	}
+	return f;
+}
+
+
+int ooh323_convert_hangupcause_asteriskToH323(int cause)
+{
+	switch (cause) {
+	case AST_CAUSE_CALL_REJECTED:
+		return OO_REASON_REMOTE_REJECTED;
+	case AST_CAUSE_UNALLOCATED:
+		return OO_REASON_NOUSER;
+	case AST_CAUSE_BUSY:
+		return OO_REASON_REMOTE_BUSY;
+	case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:
+		return OO_REASON_NOCOMMON_CAPABILITIES;
+	case AST_CAUSE_CONGESTION:
+		return OO_REASON_REMOTE_BUSY;
+	case AST_CAUSE_NO_ANSWER:
+		return OO_REASON_REMOTE_NOANSWER;
+	case AST_CAUSE_NORMAL:
+		return OO_REASON_REMOTE_CLEARED;
+	case AST_CAUSE_FAILURE:
+	default:
+		return OO_REASON_UNKNOWN;
+	}
+
+	return 0;
+}
+
+int ooh323_convert_hangupcause_h323ToAsterisk(int cause)
+{
+	switch (cause) {
+	case OO_REASON_REMOTE_REJECTED:
+		return AST_CAUSE_CALL_REJECTED;
+	case OO_REASON_NOUSER: 
+		return AST_CAUSE_UNALLOCATED;
+	case OO_REASON_REMOTE_BUSY:
+	case OO_REASON_LOCAL_BUSY:
+		return AST_CAUSE_BUSY;
+	case OO_REASON_NOCOMMON_CAPABILITIES:	/* No codecs approved */
+		return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
+	case OO_REASON_REMOTE_CONGESTED:
+	case OO_REASON_LOCAL_CONGESTED:
+		return AST_CAUSE_CONGESTION;
+	case OO_REASON_REMOTE_NOANSWER:
+		return AST_CAUSE_NO_ANSWER;
+	case OO_REASON_UNKNOWN: 
+	case OO_REASON_INVALIDMESSAGE:
+	case OO_REASON_TRANSPORTFAILURE:
+		return AST_CAUSE_FAILURE;
+	case OO_REASON_REMOTE_CLEARED:
+		return AST_CAUSE_NORMAL;
+	default:
+		return AST_CAUSE_NORMAL;
+	}
+	/* Never reached */
+	return 0;
+}
+
+#if 0
+void ast_ooh323c_exit()
+{
+	ooGkClientDestroy();
+}
+#endif
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Objective Systems H323 Channel");
diff --git a/addons/chan_ooh323.h b/addons/chan_ooh323.h
new file mode 100644
index 000000000..bce62bd11
--- /dev/null
+++ b/addons/chan_ooh323.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+#ifndef _OO_CHAN_H323_H_
+#define _OO_CHAN_H323_H_
+
+#include <asterisk.h>
+#undef PACKAGE_NAME
+#undef PACKAGE_TARNAME
+#undef PACKAGE_VERSION
+#undef PACKAGE_STRING
+#undef PACKAGE_BUGREPORT
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/param.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/signal.h>
+
+#include <asterisk/lock.h>
+#include <asterisk/channel.h>
+#include <asterisk/config.h>
+#include <asterisk/logger.h>
+#include <asterisk/module.h>
+#include <asterisk/pbx.h>
+#include <asterisk/utils.h>
+#include <asterisk/options.h>
+#include <asterisk/sched.h>
+#include <asterisk/io.h>
+#include <asterisk/causes.h>
+#include <asterisk/rtp.h>
+#include <asterisk/acl.h>
+#include <asterisk/callerid.h>
+#include <asterisk/file.h>
+#include <asterisk/cli.h>
+#include <asterisk/app.h>
+#include <asterisk/musiconhold.h>
+#include <asterisk/manager.h>
+#include <asterisk/dsp.h>
+#include <asterisk/stringfields.h>
+
+#include "ootypes.h"
+#include "ooCapability.h"
+#include "oochannels.h"
+#include "ooh323ep.h"
+#include "ooh323cDriver.h"
+#include "ooCalls.h"
+#include "ooq931.h"
+#include "ooStackCmds.h"
+#include "ooCapability.h"
+#include "ooGkClient.h"
+
+
+struct ooh323_pvt;
+struct ooh323_user;
+struct ooh323_peer;
+/* Helper functions */
+struct ooh323_user *find_user(const char * name, const char *ip);
+struct ooh323_peer *find_peer(const char * name, int port);
+void ooh323_delete_peer(struct ooh323_peer *peer);   
+
+int delete_users(void);
+int delete_peers(void);
+
+int ooh323_destroy(struct ooh323_pvt *p);
+int reload_config(int reload);
+int restart_monitor(void);
+
+int configure_local_rtp(struct ooh323_pvt *p, ooCallData* call);
+void setup_rtp_connection(ooCallData *call, const char *remoteIp, 
+                          int remotePort);
+void close_rtp_connection(ooCallData *call);
+struct ast_frame *ooh323_rtp_read
+         (struct ast_channel *ast, struct ooh323_pvt *p);
+
+void ooh323_set_write_format(ooCallData *call, int fmt);
+void ooh323_set_read_format(ooCallData *call, int fmt);
+
+int ooh323_update_capPrefsOrderForCall
+   (ooCallData *call, struct ast_codec_pref *prefs);
+
+int ooh323_convertAsteriskCapToH323Cap(int cap);
+
+int ooh323_convert_hangupcause_asteriskToH323(int cause);
+int ooh323_convert_hangupcause_h323ToAsterisk(int cause);
+int update_our_aliases(ooCallData *call, struct ooh323_pvt *p);
+
+/* h323 msg callbacks */
+int ooh323_onReceivedSetup(ooCallData *call, Q931Message *pmsg);
+int ooh323_onReceivedDigit(OOH323CallData *call, const char* digit);
+#endif
diff --git a/addons/format_mp3.c b/addons/format_mp3.c
new file mode 100644
index 000000000..2c27243e2
--- /dev/null
+++ b/addons/format_mp3.c
@@ -0,0 +1,336 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Anthony Minessale <anthmct@yahoo.com>
+ *
+ * Derived from other asterisk sound formats by
+ * Mark Spencer <markster@linux-support.net>
+ *
+ * Thanks to mpglib from http://www.mpg123.org/
+ * and Chris Stenton [jacs@gnome.co.uk]
+ * for coding the ability to play stereo and non-8khz files
+ 
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ * \brief MP3 Format Handler
+ * \ingroup formats
+ */
+
+/*** MODULEINFO
+	<defaultenabled>no</defaultenabled>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "mp3/mpg123.h"
+#include "mp3/mpglib.h"
+
+#include "asterisk/module.h"
+#include "asterisk/mod_format.h"
+#include "asterisk/logger.h"
+
+#define MP3_BUFLEN 320
+#define MP3_SCACHE 16384
+#define MP3_DCACHE 8192
+
+struct mp3_private {
+	char waste[AST_FRIENDLY_OFFSET];	/* Buffer for sending frames, etc */
+	char empty;				/* Empty character */
+	int lasttimeout;
+	int maxlen;
+	struct timeval last;
+	struct mpstr mp;
+	char sbuf[MP3_SCACHE];
+	char dbuf[MP3_DCACHE];
+	int buflen;
+	int sbuflen;
+	int dbuflen;
+	int dbufoffset;
+	int sbufoffset;
+	int lastseek;
+	int offset;
+	long seek;
+};
+
+static const char name[] = "mp3";
+
+#define BLOCKSIZE 160
+#define OUTSCALE 4096
+
+#define GAIN -4		/* 2^GAIN is the multiple to increase the volume by */
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define htoll(b) (b)
+#define htols(b) (b)
+#define ltohl(b) (b)
+#define ltohs(b) (b)
+#else
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define htoll(b)  \
+          (((((b)      ) & 0xFF) << 24) | \
+	       ((((b) >>  8) & 0xFF) << 16) | \
+		   ((((b) >> 16) & 0xFF) <<  8) | \
+		   ((((b) >> 24) & 0xFF)      ))
+#define htols(b) \
+          (((((b)      ) & 0xFF) << 8) | \
+		   ((((b) >> 8) & 0xFF)      ))
+#define ltohl(b) htoll(b)
+#define ltohs(b) htols(b)
+#else
+#error "Endianess not defined"
+#endif
+#endif
+
+
+static int mp3_open(struct ast_filestream *s)
+{
+	struct mp3_private *p = s->_private;
+	
+	InitMP3(&p->mp, OUTSCALE);
+	p->dbuflen = 0;
+	s->fr.data.ptr = s->buf;
+	s->fr.frametype = AST_FRAME_VOICE;
+	s->fr.subclass = AST_FORMAT_SLINEAR;
+	/* datalen will vary for each frame */
+	s->fr.src = name;
+	s->fr.mallocd = 0;
+	p->offset = 0;
+	return 0;
+}
+
+
+static void mp3_close(struct ast_filestream *s)
+{
+	struct mp3_private *p = s->_private;
+	
+	ExitMP3(&p->mp);
+	return;
+}
+
+static int mp3_squeue(struct ast_filestream *s) 
+{
+	struct mp3_private *p = s->_private;
+	int res=0;
+	
+	p->lastseek = ftell(s->f);
+	p->sbuflen = fread(p->sbuf, 1, MP3_SCACHE, s->f);
+	if(p->sbuflen < 0) {
+		ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", p->sbuflen, strerror(errno));
+		return -1;
+	}
+	res = decodeMP3(&p->mp,p->sbuf,p->sbuflen,p->dbuf,MP3_DCACHE,&p->dbuflen);
+	if(res != MP3_OK)
+		return -1;
+	p->sbuflen -= p->dbuflen;
+	p->dbufoffset = 0;
+	return 0;
+}
+
+static int mp3_dqueue(struct ast_filestream *s) 
+{
+	struct mp3_private *p = s->_private;
+	int res=0;
+	
+	if((res = decodeMP3(&p->mp,NULL,0,p->dbuf,MP3_DCACHE,&p->dbuflen)) == MP3_OK) {
+		p->sbuflen -= p->dbuflen;
+		p->dbufoffset = 0;
+	}
+	return res;
+}
+
+static int mp3_queue(struct ast_filestream *s)
+{
+	struct mp3_private *p = s->_private;
+	int res = 0, bytes = 0;
+	
+	if(p->seek) {
+		ExitMP3(&p->mp);
+		InitMP3(&p->mp, OUTSCALE);
+		fseek(s->f, 0, SEEK_SET);
+		p->sbuflen = p->dbuflen = p->offset = 0;
+		while(p->offset < p->seek) {
+			if(mp3_squeue(s))
+				return -1;
+			while(p->offset < p->seek && ((res = mp3_dqueue(s))) == MP3_OK) {
+				for(bytes = 0 ; bytes < p->dbuflen ; bytes++) {
+					p->dbufoffset++;
+					p->offset++;
+					if(p->offset >= p->seek)
+						break;
+				}
+			}
+			if(res == MP3_ERR)
+				return -1;
+		}
+		
+		p->seek = 0;
+		return 0;
+	}
+	if(p->dbuflen == 0) {
+		if(p->sbuflen) {
+			res = mp3_dqueue(s);
+			if(res == MP3_ERR)
+				return -1;
+		}
+		if(! p->sbuflen || res != MP3_OK) {
+			if(mp3_squeue(s))
+				return -1;
+		}
+		
+	}
+
+	return 0;
+}
+
+static struct ast_frame *mp3_read(struct ast_filestream *s, int *whennext)
+{
+
+	struct mp3_private *p = s->_private;
+	int delay =0;
+	int save=0;
+
+	/* Send a frame from the file to the appropriate channel */
+
+	if(mp3_queue(s))
+		return NULL;
+
+	if(p->dbuflen) {
+		for(p->buflen=0; p->buflen < MP3_BUFLEN && p->buflen < p->dbuflen; p->buflen++) {
+			s->buf[p->buflen] = p->dbuf[p->buflen+p->dbufoffset];
+			p->sbufoffset++;
+		}
+		p->dbufoffset += p->buflen;
+		p->dbuflen -= p->buflen;
+
+		if(p->buflen < MP3_BUFLEN) {
+			if(mp3_queue(s))
+				return NULL;
+
+			for(save = p->buflen; p->buflen < MP3_BUFLEN; p->buflen++) {
+				s->buf[p->buflen] = p->dbuf[(p->buflen-save)+p->dbufoffset];
+				p->sbufoffset++;
+			}
+			p->dbufoffset += (MP3_BUFLEN - save);
+			p->dbuflen -= (MP3_BUFLEN - save);
+
+		} 
+
+	}
+	
+	p->offset += p->buflen;
+	delay = p->buflen/2;
+	s->fr.frametype = AST_FRAME_VOICE;
+	s->fr.subclass = AST_FORMAT_SLINEAR;
+	s->fr.offset = AST_FRIENDLY_OFFSET;
+	s->fr.datalen = p->buflen;
+	s->fr.data.ptr = s->buf;
+	s->fr.mallocd = 0;
+	s->fr.samples = delay;
+	*whennext = delay;
+	return &s->fr;
+}
+
+
+static int mp3_write(struct ast_filestream *fs, struct ast_frame *f)
+{
+	ast_log(LOG_ERROR,"I Can't write MP3 only read them.\n");
+	return -1;
+
+}
+
+
+static int mp3_seek(struct ast_filestream *s, off_t sample_offset, int whence)
+{
+	struct mp3_private *p = s->_private;
+	off_t min,max,cur;
+	long offset=0,samples;
+	samples = sample_offset * 2;
+
+	min = 0;
+	fseek(s->f, 0, SEEK_END);
+	max = ftell(s->f) * 100;
+	cur = p->offset;
+
+	if (whence == SEEK_SET)
+		offset = samples + min;
+	else if (whence == SEEK_CUR || whence == SEEK_FORCECUR)
+		offset = samples + cur;
+	else if (whence == SEEK_END)
+		offset = max - samples;
+	if (whence != SEEK_FORCECUR) {
+		offset = (offset > max)?max:offset;
+	}
+
+	p->seek = offset;
+	return p->seek;
+	
+}
+
+static int mp3_rewrite(struct ast_filestream *s, const char *comment) 
+{
+	ast_log(LOG_ERROR,"I Can't write MP3 only read them.\n");
+	return -1;
+}
+
+static int mp3_trunc(struct ast_filestream *s) 
+{
+
+	ast_log(LOG_ERROR,"I Can't write MP3 only read them.\n");
+	return -1;
+}
+
+static off_t mp3_tell(struct ast_filestream *s)
+{
+	struct mp3_private *p = s->_private;
+	
+	return p->offset/2;
+}
+
+static char *mp3_getcomment(struct ast_filestream *s)
+{
+	return NULL;
+}
+
+static const struct ast_format mp3_f = {
+	.name = "mp3",
+	.exts = "mp3",
+	.format = AST_FORMAT_SLINEAR,
+	.open = mp3_open,
+	.write = mp3_write,
+	.rewrite = mp3_rewrite,
+	.seek =	mp3_seek,
+	.trunc = mp3_trunc,
+	.tell =	mp3_tell,
+	.read =	mp3_read,
+	.close = mp3_close,
+	.getcomment = mp3_getcomment,
+	.buf_size = MP3_BUFLEN + AST_FRIENDLY_OFFSET,
+	.desc_size = sizeof(struct mp3_private),
+};
+
+
+static int load_module(void)
+{
+	InitMP3Constants();
+	return ast_format_register(&mp3_f);
+}
+
+static int unload_module(void)
+{
+	return ast_format_unregister(name);
+}	
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "MP3 format [Any rate but 8000hz mono is optimal]");
diff --git a/addons/mp3/MPGLIB_README b/addons/mp3/MPGLIB_README
new file mode 100644
index 000000000..3c5f33749
--- /dev/null
+++ b/addons/mp3/MPGLIB_README
@@ -0,0 +1,39 @@
+MP3 library
+-----------
+Version 0.2
+
+This decoder is a 'light' version (thrown out all unnecessay parts)
+from the mpg123 package. I made this for a company.
+
+Currently only Layer3 is enabled to save some space. Layer1,2 isn't
+tested at all. The interface will not change significantly. 
+A backport to the mpg123 package is planed.
+
+comiled and tested only on Solaris 2.6
+main.c contains a simple demo application for library.
+
+COPYING: you may use this source under GPL terms!
+
+PLEASE NOTE: This software may contain patented alogrithm (at least
+  patented in some countries). It may be not allowed to sell/use products
+  based on this source code in these countries. Check this out first!
+
+COPYRIGHT of MP3 music:
+  Please note, that the duplicating of copyrighted music without explicit
+  permission violates the rights of the owner.
+
+SENDING PATCHES:
+  Maybe I change the copyright policy (ie some kind of more free BSD licencse).
+  Please consider this when sending patches/changes.
+  I also want to have the freedom to sell the code to companies that
+  can not use the code under GPL. So, if you send me significant patches,
+  I need your explicit permission to do this. Of course, there will also 
+  be the GPLed open source version of the 100% same code.
+  For the case you cannot accept this: the code is GPL, it's your freedom 
+  to distribute your changes again under GPL. 
+
+FEEDBACK:
+  I'm interessted to here from you, when you use this package as part
+  of another project.
+
+
diff --git a/addons/mp3/MPGLIB_TODO b/addons/mp3/MPGLIB_TODO
new file mode 100644
index 000000000..403711010
--- /dev/null
+++ b/addons/mp3/MPGLIB_TODO
@@ -0,0 +1,2 @@
+
+apply 'VBR' bugfix
diff --git a/addons/mp3/Makefile b/addons/mp3/Makefile
new file mode 100644
index 000000000..7cd0b58d1
--- /dev/null
+++ b/addons/mp3/Makefile
@@ -0,0 +1,24 @@
+MP3OBJS=common.o dct64_i386.o decode_ntom.o layer3.o tabinit.o interface.o
+
+ifeq ($(OSARCH),FreeBSD)
+OSVERSION=$(shell make -V OSVERSION -f /usr/share/mk/bsd.port.subdir.mk)
+CFLAGS+=$(if $(OSVERSION)<500016,-D_THREAD_SAFE)
+LIBS+=$(if $(OSVERSION)<502102,-lc_r,-pthread)
+INCLUDE+=-I/usr/local/include
+CFLAGS+=$(shell if [ -d /usr/local/include/spandsp ]; then echo "-I/usr/local/include/spandsp"; fi)
+endif # FreeBSD
+
+ifeq ($(OSARCH),NetBSD)
+CFLAGS+=-pthread
+INCLUDE+=-I/usr/local/include
+endif
+
+ifeq ($(OSARCH),OpenBSD)
+CFLAGS+=-pthread
+endif
+
+all: $(MP3OBJS)
+
+clean:
+	rm -f *.o *.so *~
+	rm -f .*.o.d
diff --git a/addons/mp3/README b/addons/mp3/README
new file mode 100644
index 000000000..9263da487
--- /dev/null
+++ b/addons/mp3/README
@@ -0,0 +1,24 @@
+This is a module for asterisk to play mp3 natively.
+They *SHOULD* be already at 8khz and *SHOULD* be mono.
+otherwise they will be consuming CPU alot more than need be.
+
+Convert them to 8k mono like this:
+lame -q -p --mp3input -a --preset 8 in.mp3 8kout.mp3
+
+just run 
+# make clean install 
+to install 
+
+or
+# make clean autoload
+to install and autoload at the same time
+
+
+Comments or improvements
+Anthony Minessale <anthmct@yahoo.com>
+
+Donations Welcomed at paypal:jillkm3@yahoo.com
+
+
+
+
diff --git a/addons/mp3/common.c b/addons/mp3/common.c
new file mode 100644
index 000000000..d8db2a3d2
--- /dev/null
+++ b/addons/mp3/common.c
@@ -0,0 +1,267 @@
+#include <asterisk.h>
+#include <asterisk/logger.h>
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <signal.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "mpg123.h"
+#include "mpglib.h"
+
+struct parameter param = { 1 , 1 , 0 , 0 };
+
+int tabsel_123[2][3][16] = {
+   { {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
+     {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
+     {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,} },
+
+   { {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
+     {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
+     {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,} }
+};
+
+long freqs[9] = { 44100, 48000, 32000,
+                  22050, 24000, 16000 ,
+                  11025 , 12000 , 8000 };
+
+
+#if 0
+static void get_II_stuff(struct frame *fr)
+{
+  static int translate[3][2][16] = 
+   { { { 0,2,2,2,2,2,2,0,0,0,1,1,1,1,1,0 } ,
+       { 0,2,2,0,0,0,1,1,1,1,1,1,1,1,1,0 } } ,
+     { { 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0 } ,
+       { 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0 } } ,
+     { { 0,3,3,3,3,3,3,0,0,0,1,1,1,1,1,0 } ,
+       { 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0 } } };
+
+  int table,sblim;
+  static struct al_table *tables[5] = 
+       { alloc_0, alloc_1, alloc_2, alloc_3 , alloc_4 };
+  static int sblims[5] = { 27 , 30 , 8, 12 , 30 };
+
+  if(fr->lsf)
+    table = 4;
+  else
+    table = translate[fr->sampling_frequency][2-fr->stereo][fr->bitrate_index];
+  sblim = sblims[table];
+
+  fr->alloc = tables[table];
+  fr->II_sblimit = sblim;
+}
+#endif
+
+#define HDRCMPMASK 0xfffffd00
+
+#if 0
+int head_check(unsigned long head)
+{
+    if( (head & 0xffe00000) != 0xffe00000)
+	return FALSE;
+    if(!((head>>17)&3))
+	return FALSE;
+    if( ((head>>12)&0xf) == 0xf)
+	return FALSE;
+    if( ((head>>10)&0x3) == 0x3 )
+	return FALSE;
+    return TRUE;
+}
+#endif
+
+
+/*
+ * the code a header and write the information
+ * into the frame structure
+ */
+int decode_header(struct frame *fr,unsigned long newhead)
+{
+    if( newhead & (1<<20) ) {
+      fr->lsf = (newhead & (1<<19)) ? 0x0 : 0x1;
+      fr->mpeg25 = 0;
+    }
+    else {
+      fr->lsf = 1;
+      fr->mpeg25 = 1;
+    }
+    
+    fr->lay = 4-((newhead>>17)&3);
+    if( ((newhead>>10)&0x3) == 0x3) {
+      ast_log(LOG_WARNING,"Stream error\n");
+      return (0);
+    }
+    if(fr->mpeg25) {
+      fr->sampling_frequency = 6 + ((newhead>>10)&0x3);
+    }
+    else
+      fr->sampling_frequency = ((newhead>>10)&0x3) + (fr->lsf*3);
+    fr->error_protection = ((newhead>>16)&0x1)^0x1;
+
+    if(fr->mpeg25) /* allow Bitrate change for 2.5 ... */
+      fr->bitrate_index = ((newhead>>12)&0xf);
+
+    fr->bitrate_index = ((newhead>>12)&0xf);
+    fr->padding   = ((newhead>>9)&0x1);
+    fr->extension = ((newhead>>8)&0x1);
+    fr->mode      = ((newhead>>6)&0x3);
+    fr->mode_ext  = ((newhead>>4)&0x3);
+    fr->copyright = ((newhead>>3)&0x1);
+    fr->original  = ((newhead>>2)&0x1);
+    fr->emphasis  = newhead & 0x3;
+
+    fr->stereo    = (fr->mode == MPG_MD_MONO) ? 1 : 2;
+
+    if(!fr->bitrate_index)
+    {
+      ast_log(LOG_WARNING,"Free format not supported.\n");
+      return (0);
+    }
+
+    switch(fr->lay)
+    {
+      case 1:
+#if 0
+		fr->do_layer = do_layer1;
+        fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? 
+                         (fr->mode_ext<<2)+4 : 32;
+        fr->framesize  = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000;
+        fr->framesize /= freqs[fr->sampling_frequency];
+        fr->framesize  = ((fr->framesize+fr->padding)<<2)-4;
+#else
+        ast_log(LOG_WARNING,"Layer 1 not supported!\n");
+#endif
+        break;
+      case 2:
+#if 0
+		fr->do_layer = do_layer2;
+        get_II_stuff(fr);
+        fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ?
+                         (fr->mode_ext<<2)+4 : fr->II_sblimit;
+        fr->framesize = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000;
+        fr->framesize /= freqs[fr->sampling_frequency];
+        fr->framesize += fr->padding - 4;
+#else
+        ast_log(LOG_WARNING,"Layer 2 not supported!\n");
+#endif
+        break;
+      case 3:
+#if 0
+        fr->do_layer = do_layer3;
+        if(fr->lsf)
+          ssize = (fr->stereo == 1) ? 9 : 17;
+        else
+          ssize = (fr->stereo == 1) ? 17 : 32;
+#endif
+
+#if 0
+        if(fr->error_protection)
+          ssize += 2;
+#endif
+          fr->framesize  = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000;
+          fr->framesize /= freqs[fr->sampling_frequency]<<(fr->lsf);
+          fr->framesize = fr->framesize + fr->padding - 4;
+        break; 
+      default:
+        ast_log(LOG_WARNING,"Sorry, unknown layer type.\n"); 
+        return (0);
+    }
+    return 1;
+}
+
+#if 0
+void print_header(struct frame *fr)
+{
+	static char *modes[4] = { "Stereo", "Joint-Stereo", "Dual-Channel", "Single-Channel" };
+	static char *layers[4] = { "Unknown" , "I", "II", "III" };
+
+	ast_log(LOG_WARNING,"MPEG %s, Layer: %s, Freq: %ld, mode: %s, modext: %d, BPF : %d\n", 
+		fr->mpeg25 ? "2.5" : (fr->lsf ? "2.0" : "1.0"),
+		layers[fr->lay],freqs[fr->sampling_frequency],
+		modes[fr->mode],fr->mode_ext,fr->framesize+4);
+	ast_log(LOG_WARNING,"Channels: %d, copyright: %s, original: %s, CRC: %s, emphasis: %d.\n",
+		fr->stereo,fr->copyright?"Yes":"No",
+		fr->original?"Yes":"No",fr->error_protection?"Yes":"No",
+		fr->emphasis);
+	ast_log(LOG_WARNING,"Bitrate: %d Kbits/s, Extension value: %d\n",
+		tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index],fr->extension);
+}
+
+void print_header_compact(struct frame *fr)
+{
+	static char *modes[4] = { "stereo", "joint-stereo", "dual-channel", "mono" };
+	static char *layers[4] = { "Unknown" , "I", "II", "III" };
+ 
+	ast_log(LOG_WARNING,"MPEG %s layer %s, %d kbit/s, %ld Hz %s\n",
+		fr->mpeg25 ? "2.5" : (fr->lsf ? "2.0" : "1.0"),
+		layers[fr->lay],
+		tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index],
+		freqs[fr->sampling_frequency], modes[fr->mode]);
+}
+
+#endif
+
+unsigned int getbits(struct mpstr *mp, int number_of_bits)
+{
+  unsigned long rval;
+
+  if(!number_of_bits)
+    return 0;
+
+  {
+    rval = (mp->worksample).wordpointer[0];
+    rval <<= 8;
+    rval |= (mp->worksample).wordpointer[1];
+    rval <<= 8;
+    rval |= (mp->worksample).wordpointer[2];
+    rval <<= (mp->worksample).bitindex;
+    rval &= 0xffffff;
+
+    (mp->worksample).bitindex += number_of_bits;
+
+    rval >>= (24-number_of_bits);
+
+    (mp->worksample).wordpointer += ((mp->worksample).bitindex>>3);
+    (mp->worksample).bitindex &= 7;
+  }
+  return rval;
+}
+
+unsigned int getbits_fast(struct mpstr *mp, int number_of_bits)
+{
+  unsigned long rval;
+
+  {
+    rval = (mp->worksample).wordpointer[0];
+    rval <<= 8;	
+    rval |= (mp->worksample).wordpointer[1];
+    rval <<= (mp->worksample).bitindex;
+    rval &= 0xffff;
+    (mp->worksample).bitindex += number_of_bits;
+
+    rval >>= (16-number_of_bits);
+
+    (mp->worksample).wordpointer += ((mp->worksample).bitindex>>3);
+    (mp->worksample).bitindex &= 7;
+  }
+  return rval;
+}
+
+unsigned int get1bit(struct mpstr *mp)
+{
+  unsigned char rval;
+
+  rval = *((mp->worksample).wordpointer) << (mp->worksample).bitindex;
+
+  (mp->worksample).bitindex++;
+  (mp->worksample).wordpointer += ((mp->worksample).bitindex>>3);
+  (mp->worksample).bitindex &= 7;
+
+  return rval>>7;
+}
+
+
+
diff --git a/addons/mp3/dct64_i386.c b/addons/mp3/dct64_i386.c
new file mode 100644
index 000000000..c6b5d886c
--- /dev/null
+++ b/addons/mp3/dct64_i386.c
@@ -0,0 +1,335 @@
+
+/*
+ * Discrete Cosine Tansform (DCT) for subband synthesis
+ * optimized for machines with no auto-increment. 
+ * The performance is highly compiler dependend. Maybe
+ * the dct64.c version for 'normal' processor may be faster
+ * even for Intel processors.
+ */
+
+#include "mpg123.h"
+
+/*
+ * the call via dct64 is a trick to force GCC to use
+ * (new) registers for the b1,b2 pointer to the bufs[xx] field
+ */
+void dct64(real *a,real *b,real *c);
+
+static void dct64_1(real *out0,real *out1,real *b1,real *b2,real *samples)
+{
+ {
+  register real *costab = pnts[0];
+
+  b1[0x00] = samples[0x00] + samples[0x1F];
+  b1[0x01] = samples[0x01] + samples[0x1E];
+  b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0];
+  b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1];
+
+  b1[0x02] = samples[0x02] + samples[0x1D];
+  b1[0x03] = samples[0x03] + samples[0x1C];
+  b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2];
+  b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3];
+
+  b1[0x04] = samples[0x04] + samples[0x1B];
+  b1[0x05] = samples[0x05] + samples[0x1A];
+  b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4];
+  b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5];
+
+  b1[0x06] = samples[0x06] + samples[0x19];
+  b1[0x07] = samples[0x07] + samples[0x18];
+  b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6];
+  b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7];
+
+  b1[0x08] = samples[0x08] + samples[0x17];
+  b1[0x09] = samples[0x09] + samples[0x16];
+  b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8];
+  b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9];
+
+  b1[0x0A] = samples[0x0A] + samples[0x15];
+  b1[0x0B] = samples[0x0B] + samples[0x14];
+  b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA];
+  b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB];
+
+  b1[0x0C] = samples[0x0C] + samples[0x13];
+  b1[0x0D] = samples[0x0D] + samples[0x12];
+  b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC];
+  b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD];
+
+  b1[0x0E] = samples[0x0E] + samples[0x11];
+  b1[0x0F] = samples[0x0F] + samples[0x10];
+  b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE];
+  b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF];
+
+ }
+
+
+ {
+  register real *costab = pnts[1];
+
+  b2[0x00] = b1[0x00] + b1[0x0F]; 
+  b2[0x01] = b1[0x01] + b1[0x0E]; 
+  b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0];
+  b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1];
+
+  b2[0x02] = b1[0x02] + b1[0x0D]; 
+  b2[0x03] = b1[0x03] + b1[0x0C]; 
+  b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2];
+  b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3];
+
+  b2[0x04] = b1[0x04] + b1[0x0B]; 
+  b2[0x05] = b1[0x05] + b1[0x0A]; 
+  b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4];
+  b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5];
+
+  b2[0x06] = b1[0x06] + b1[0x09]; 
+  b2[0x07] = b1[0x07] + b1[0x08]; 
+  b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6];
+  b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7];
+
+  /* */
+
+  b2[0x10] = b1[0x10] + b1[0x1F];
+  b2[0x11] = b1[0x11] + b1[0x1E];
+  b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0];
+  b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1];
+
+  b2[0x12] = b1[0x12] + b1[0x1D];
+  b2[0x13] = b1[0x13] + b1[0x1C];
+  b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2];
+  b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3];
+
+  b2[0x14] = b1[0x14] + b1[0x1B];
+  b2[0x15] = b1[0x15] + b1[0x1A];
+  b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4];
+  b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5];
+
+  b2[0x16] = b1[0x16] + b1[0x19];
+  b2[0x17] = b1[0x17] + b1[0x18];
+  b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6];
+  b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7];
+ }
+
+ {
+  register real *costab = pnts[2];
+
+  b1[0x00] = b2[0x00] + b2[0x07];
+  b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0];
+  b1[0x01] = b2[0x01] + b2[0x06];
+  b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1];
+  b1[0x02] = b2[0x02] + b2[0x05];
+  b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2];
+  b1[0x03] = b2[0x03] + b2[0x04];
+  b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3];
+
+  b1[0x08] = b2[0x08] + b2[0x0F];
+  b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0];
+  b1[0x09] = b2[0x09] + b2[0x0E];
+  b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1];
+  b1[0x0A] = b2[0x0A] + b2[0x0D];
+  b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2];
+  b1[0x0B] = b2[0x0B] + b2[0x0C];
+  b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3];
+
+  b1[0x10] = b2[0x10] + b2[0x17];
+  b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0];
+  b1[0x11] = b2[0x11] + b2[0x16];
+  b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1];
+  b1[0x12] = b2[0x12] + b2[0x15];
+  b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2];
+  b1[0x13] = b2[0x13] + b2[0x14];
+  b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3];
+
+  b1[0x18] = b2[0x18] + b2[0x1F];
+  b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0];
+  b1[0x19] = b2[0x19] + b2[0x1E];
+  b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1];
+  b1[0x1A] = b2[0x1A] + b2[0x1D];
+  b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2];
+  b1[0x1B] = b2[0x1B] + b2[0x1C];
+  b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3];
+ }
+
+ {
+  register real const cos0 = pnts[3][0];
+  register real const cos1 = pnts[3][1];
+
+  b2[0x00] = b1[0x00] + b1[0x03];
+  b2[0x03] = (b1[0x00] - b1[0x03]) * cos0;
+  b2[0x01] = b1[0x01] + b1[0x02];
+  b2[0x02] = (b1[0x01] - b1[0x02]) * cos1;
+
+  b2[0x04] = b1[0x04] + b1[0x07];
+  b2[0x07] = (b1[0x07] - b1[0x04]) * cos0;
+  b2[0x05] = b1[0x05] + b1[0x06];
+  b2[0x06] = (b1[0x06] - b1[0x05]) * cos1;
+
+  b2[0x08] = b1[0x08] + b1[0x0B];
+  b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0;
+  b2[0x09] = b1[0x09] + b1[0x0A];
+  b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1;
+  
+  b2[0x0C] = b1[0x0C] + b1[0x0F];
+  b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0;
+  b2[0x0D] = b1[0x0D] + b1[0x0E];
+  b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1;
+
+  b2[0x10] = b1[0x10] + b1[0x13];
+  b2[0x13] = (b1[0x10] - b1[0x13]) * cos0;
+  b2[0x11] = b1[0x11] + b1[0x12];
+  b2[0x12] = (b1[0x11] - b1[0x12]) * cos1;
+
+  b2[0x14] = b1[0x14] + b1[0x17];
+  b2[0x17] = (b1[0x17] - b1[0x14]) * cos0;
+  b2[0x15] = b1[0x15] + b1[0x16];
+  b2[0x16] = (b1[0x16] - b1[0x15]) * cos1;
+
+  b2[0x18] = b1[0x18] + b1[0x1B];
+  b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0;
+  b2[0x19] = b1[0x19] + b1[0x1A];
+  b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1;
+
+  b2[0x1C] = b1[0x1C] + b1[0x1F];
+  b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0;
+  b2[0x1D] = b1[0x1D] + b1[0x1E];
+  b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1;
+ }
+
+ {
+  register real const cos0 = pnts[4][0];
+
+  b1[0x00] = b2[0x00] + b2[0x01];
+  b1[0x01] = (b2[0x00] - b2[0x01]) * cos0;
+  b1[0x02] = b2[0x02] + b2[0x03];
+  b1[0x03] = (b2[0x03] - b2[0x02]) * cos0;
+  b1[0x02] += b1[0x03];
+
+  b1[0x04] = b2[0x04] + b2[0x05];
+  b1[0x05] = (b2[0x04] - b2[0x05]) * cos0;
+  b1[0x06] = b2[0x06] + b2[0x07];
+  b1[0x07] = (b2[0x07] - b2[0x06]) * cos0;
+  b1[0x06] += b1[0x07];
+  b1[0x04] += b1[0x06];
+  b1[0x06] += b1[0x05];
+  b1[0x05] += b1[0x07];
+
+  b1[0x08] = b2[0x08] + b2[0x09];
+  b1[0x09] = (b2[0x08] - b2[0x09]) * cos0;
+  b1[0x0A] = b2[0x0A] + b2[0x0B];
+  b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0;
+  b1[0x0A] += b1[0x0B];
+
+  b1[0x0C] = b2[0x0C] + b2[0x0D];
+  b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0;
+  b1[0x0E] = b2[0x0E] + b2[0x0F];
+  b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0;
+  b1[0x0E] += b1[0x0F];
+  b1[0x0C] += b1[0x0E];
+  b1[0x0E] += b1[0x0D];
+  b1[0x0D] += b1[0x0F];
+
+  b1[0x10] = b2[0x10] + b2[0x11];
+  b1[0x11] = (b2[0x10] - b2[0x11]) * cos0;
+  b1[0x12] = b2[0x12] + b2[0x13];
+  b1[0x13] = (b2[0x13] - b2[0x12]) * cos0;
+  b1[0x12] += b1[0x13];
+
+  b1[0x14] = b2[0x14] + b2[0x15];
+  b1[0x15] = (b2[0x14] - b2[0x15]) * cos0;
+  b1[0x16] = b2[0x16] + b2[0x17];
+  b1[0x17] = (b2[0x17] - b2[0x16]) * cos0;
+  b1[0x16] += b1[0x17];
+  b1[0x14] += b1[0x16];
+  b1[0x16] += b1[0x15];
+  b1[0x15] += b1[0x17];
+
+  b1[0x18] = b2[0x18] + b2[0x19];
+  b1[0x19] = (b2[0x18] - b2[0x19]) * cos0;
+  b1[0x1A] = b2[0x1A] + b2[0x1B];
+  b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0;
+  b1[0x1A] += b1[0x1B];
+
+  b1[0x1C] = b2[0x1C] + b2[0x1D];
+  b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0;
+  b1[0x1E] = b2[0x1E] + b2[0x1F];
+  b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0;
+  b1[0x1E] += b1[0x1F];
+  b1[0x1C] += b1[0x1E];
+  b1[0x1E] += b1[0x1D];
+  b1[0x1D] += b1[0x1F];
+ }
+
+ out0[0x10*16] = b1[0x00];
+ out0[0x10*12] = b1[0x04];
+ out0[0x10* 8] = b1[0x02];
+ out0[0x10* 4] = b1[0x06];
+ out0[0x10* 0] = b1[0x01];
+ out1[0x10* 0] = b1[0x01];
+ out1[0x10* 4] = b1[0x05];
+ out1[0x10* 8] = b1[0x03];
+ out1[0x10*12] = b1[0x07];
+
+#if 1
+ out0[0x10*14] = b1[0x08] + b1[0x0C];
+ out0[0x10*10] = b1[0x0C] + b1[0x0a];
+ out0[0x10* 6] = b1[0x0A] + b1[0x0E];
+ out0[0x10* 2] = b1[0x0E] + b1[0x09];
+ out1[0x10* 2] = b1[0x09] + b1[0x0D];
+ out1[0x10* 6] = b1[0x0D] + b1[0x0B];
+ out1[0x10*10] = b1[0x0B] + b1[0x0F];
+ out1[0x10*14] = b1[0x0F];
+#else
+ b1[0x08] += b1[0x0C];
+ out0[0x10*14] = b1[0x08];
+ b1[0x0C] += b1[0x0a];
+ out0[0x10*10] = b1[0x0C];
+ b1[0x0A] += b1[0x0E];
+ out0[0x10* 6] = b1[0x0A];
+ b1[0x0E] += b1[0x09];
+ out0[0x10* 2] = b1[0x0E];
+ b1[0x09] += b1[0x0D];
+ out1[0x10* 2] = b1[0x09];
+ b1[0x0D] += b1[0x0B];
+ out1[0x10* 6] = b1[0x0D];
+ b1[0x0B] += b1[0x0F];
+ out1[0x10*10] = b1[0x0B];
+ out1[0x10*14] = b1[0x0F];
+#endif
+
+ { 
+ real tmp;
+ tmp = b1[0x18] + b1[0x1C];
+ out0[0x10*15] = tmp + b1[0x10];
+ out0[0x10*13] = tmp + b1[0x14];
+ tmp = b1[0x1C] + b1[0x1A];
+ out0[0x10*11] = tmp + b1[0x14];
+ out0[0x10* 9] = tmp + b1[0x12];
+ tmp = b1[0x1A] + b1[0x1E];
+ out0[0x10* 7] = tmp + b1[0x12];
+ out0[0x10* 5] = tmp + b1[0x16];
+ tmp = b1[0x1E] + b1[0x19];
+ out0[0x10* 3] = tmp + b1[0x16];
+ out0[0x10* 1] = tmp + b1[0x11];
+ tmp = b1[0x19] + b1[0x1D];
+ out1[0x10* 1] = tmp + b1[0x11];
+ out1[0x10* 3] = tmp + b1[0x15]; 
+ tmp = b1[0x1D] + b1[0x1B];
+ out1[0x10* 5] = tmp + b1[0x15];
+ out1[0x10* 7] = tmp + b1[0x13];
+ tmp = b1[0x1B] + b1[0x1F];
+ out1[0x10* 9] = tmp + b1[0x13];
+ out1[0x10*11] = tmp + b1[0x17];
+ out1[0x10*13] = b1[0x17] + b1[0x1F];
+ out1[0x10*15] = b1[0x1F];
+ }
+}
+
+/*
+ * the call via dct64 is a trick to force GCC to use
+ * (new) registers for the b1,b2 pointer to the bufs[xx] field
+ */
+void dct64(real *a,real *b,real *c)
+{
+  real bufs[0x40];
+  dct64_1(a,b,bufs,bufs+0x20,c);
+}
+
diff --git a/addons/mp3/decode_i386.c b/addons/mp3/decode_i386.c
new file mode 100644
index 000000000..83e054422
--- /dev/null
+++ b/addons/mp3/decode_i386.c
@@ -0,0 +1,153 @@
+/* 
+ * Mpeg Layer-1,2,3 audio decoder 
+ * ------------------------------
+ * copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved.
+ * See also 'README'
+ *
+ * slighlty optimized for machines without autoincrement/decrement.
+ * The performance is highly compiler dependend. Maybe
+ * the decode.c version for 'normal' processor may be faster
+ * even for Intel processors.
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+
+#include "mpglib.h"
+
+
+
+ /* old WRITE_SAMPLE */
+#define WRITE_SAMPLE(samples,sum,clip) \
+  if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \
+  else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \
+  else { *(samples) = sum; }
+
+int synth_1to1_mono(struct mpstr *mp,real *bandPtr,unsigned char *samples,int *pnt)
+{
+  short samples_tmp[64];
+  short *tmp1 = samples_tmp;
+  int i,ret;
+  int pnt1 = 0;
+
+  ret = synth_1to1(mp,bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
+  samples += *pnt;
+
+  for(i=0;i<32;i++) {
+    *( (short *) samples) = *tmp1;
+    samples += 2;
+    tmp1 += 2;
+  }
+  *pnt += 64;
+
+  return ret;
+}
+
+
+int synth_1to1(struct mpstr *mp, real *bandPtr,int channel,unsigned char *out,int *pnt)
+{
+  static const int step = 2;
+  int bo;
+  short *samples = (short *) (out + *pnt);
+
+  real *b0,(*buf)[0x110];
+  int clip = 0; 
+  int bo1;
+
+  bo = mp->synth_bo;
+
+  if(!channel) {
+    bo--;
+    bo &= 0xf;
+    buf = mp->synth_buffs[0];
+  }
+  else {
+    samples++;
+    buf = mp->synth_buffs[1];
+  }
+
+  if(bo & 0x1) {
+    b0 = buf[0];
+    bo1 = bo;
+    dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr);
+  }
+  else {
+    b0 = buf[1];
+    bo1 = bo+1;
+    dct64(buf[0]+bo,buf[1]+bo+1,bandPtr);
+  }
+
+  mp->synth_bo = bo;
+  
+  {
+    register int j;
+    real *window = decwin + 16 - bo1;
+
+    for (j=16;j;j--,b0+=0x10,window+=0x20,samples+=step)
+    {
+      real sum;
+      sum  = window[0x0] * b0[0x0];
+      sum -= window[0x1] * b0[0x1];
+      sum += window[0x2] * b0[0x2];
+      sum -= window[0x3] * b0[0x3];
+      sum += window[0x4] * b0[0x4];
+      sum -= window[0x5] * b0[0x5];
+      sum += window[0x6] * b0[0x6];
+      sum -= window[0x7] * b0[0x7];
+      sum += window[0x8] * b0[0x8];
+      sum -= window[0x9] * b0[0x9];
+      sum += window[0xA] * b0[0xA];
+      sum -= window[0xB] * b0[0xB];
+      sum += window[0xC] * b0[0xC];
+      sum -= window[0xD] * b0[0xD];
+      sum += window[0xE] * b0[0xE];
+      sum -= window[0xF] * b0[0xF];
+
+      WRITE_SAMPLE(samples,sum,clip);
+    }
+
+    {
+      real sum;
+      sum  = window[0x0] * b0[0x0];
+      sum += window[0x2] * b0[0x2];
+      sum += window[0x4] * b0[0x4];
+      sum += window[0x6] * b0[0x6];
+      sum += window[0x8] * b0[0x8];
+      sum += window[0xA] * b0[0xA];
+      sum += window[0xC] * b0[0xC];
+      sum += window[0xE] * b0[0xE];
+      WRITE_SAMPLE(samples,sum,clip);
+      b0-=0x10,window-=0x20,samples+=step;
+    }
+    window += bo1<<1;
+
+    for (j=15;j;j--,b0-=0x10,window-=0x20,samples+=step)
+    {
+      real sum;
+      sum = -window[-0x1] * b0[0x0];
+      sum -= window[-0x2] * b0[0x1];
+      sum -= window[-0x3] * b0[0x2];
+      sum -= window[-0x4] * b0[0x3];
+      sum -= window[-0x5] * b0[0x4];
+      sum -= window[-0x6] * b0[0x5];
+      sum -= window[-0x7] * b0[0x6];
+      sum -= window[-0x8] * b0[0x7];
+      sum -= window[-0x9] * b0[0x8];
+      sum -= window[-0xA] * b0[0x9];
+      sum -= window[-0xB] * b0[0xA];
+      sum -= window[-0xC] * b0[0xB];
+      sum -= window[-0xD] * b0[0xC];
+      sum -= window[-0xE] * b0[0xD];
+      sum -= window[-0xF] * b0[0xE];
+      sum -= window[-0x0] * b0[0xF];
+
+      WRITE_SAMPLE(samples,sum,clip);
+    }
+  }
+  *pnt += 128;
+
+  return clip;
+}
+
diff --git a/addons/mp3/decode_ntom.c b/addons/mp3/decode_ntom.c
new file mode 100644
index 000000000..b231f439f
--- /dev/null
+++ b/addons/mp3/decode_ntom.c
@@ -0,0 +1,219 @@
+/* 
+ * Mpeg Layer-1,2,3 audio decoder 
+ * ------------------------------
+ * copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved.
+ * See also 'README'
+ *
+ * N->M down/up sampling. Not optimized for speed.
+ */
+
+#include <asterisk.h>
+#include <asterisk/logger.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#include "mpg123.h"
+#include "mpglib.h"
+
+#define WRITE_SAMPLE(samples,sum,clip) \
+  if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \
+  else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \
+  else { *(samples) = sum; }
+
+#define NTOM_MUL (32768)
+static unsigned long ntom_val[2] = { NTOM_MUL>>1,NTOM_MUL>>1 };
+static unsigned long ntom_step = NTOM_MUL;
+
+
+int synth_ntom_set_step(long m,long n)
+{
+	if(param.verbose > 1)
+		ast_log(LOG_WARNING,"Init rate converter: %ld->%ld\n",m,n);
+
+	if(n >= 96000 || m >= 96000 || m == 0 || n == 0) {
+		ast_log(LOG_WARNING,"NtoM converter: illegal rates\n");
+		return (1);
+	}
+
+	n *= NTOM_MUL;
+	ntom_step = n / m;
+
+	if(ntom_step > 8*NTOM_MUL) {
+		ast_log(LOG_WARNING,"max. 1:8 conversion allowed!\n");
+		return (1);
+	}
+
+	ntom_val[0] = ntom_val[1] = NTOM_MUL>>1;
+
+	return (0);
+	
+}
+
+
+int synth_ntom_mono (struct mpstr *mp, real *bandPtr,unsigned char *samples,int *pnt)
+{
+  short samples_tmp[8*64];
+  short *tmp1 = samples_tmp;
+  int i,ret;
+  int pnt1 = 0;
+
+  ret = synth_ntom(mp, bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
+  samples += *pnt;
+
+  for(i=0;i<(pnt1>>2);i++) {
+    *( (short *)samples) = *tmp1;
+    samples += 2;
+    tmp1 += 2;
+  }
+  *pnt += pnt1 >> 1;
+
+  return ret;
+}
+
+
+
+int synth_ntom(struct mpstr *mp, real *bandPtr,int channel,unsigned char *out,int *pnt)
+{
+  static const int step = 2;
+  int bo;
+  short *samples = (short *) (out + *pnt);
+
+  real *b0,(*buf)[0x110];
+  int clip = 0; 
+  int bo1;
+  int ntom;
+
+  bo = mp->synth_bo;
+  
+  if(!channel) {
+    bo--;
+    bo &= 0xf;
+    buf = mp->synth_buffs[0];
+    ntom = ntom_val[1] = ntom_val[0];
+  }
+  else {
+    samples++;
+    out += 2; /* to compute the right *pnt value */
+    buf = mp->synth_buffs[1];
+    ntom = ntom_val[1];
+  }
+
+  if(bo & 0x1) {
+    b0 = buf[0];
+    bo1 = bo;
+    dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr);
+  }
+  else {
+    b0 = buf[1];
+    bo1 = bo+1;
+    dct64(buf[0]+bo,buf[1]+bo+1,bandPtr);
+  }
+
+  mp->synth_bo = bo;
+  
+  {
+    register int j;
+    real *window = (mp->decwin) + 16 - bo1;
+ 
+    for (j=16;j;j--,window+=0x10)
+    {
+      real sum;
+
+      ntom += ntom_step;
+      if(ntom < NTOM_MUL) {
+        window += 16;
+        b0 += 16;
+        continue;
+      }
+
+      sum  = *window++ * *b0++;
+      sum -= *window++ * *b0++;
+      sum += *window++ * *b0++;
+      sum -= *window++ * *b0++;
+      sum += *window++ * *b0++;
+      sum -= *window++ * *b0++;
+      sum += *window++ * *b0++;
+      sum -= *window++ * *b0++;
+      sum += *window++ * *b0++;
+      sum -= *window++ * *b0++;
+      sum += *window++ * *b0++;
+      sum -= *window++ * *b0++;
+      sum += *window++ * *b0++;
+      sum -= *window++ * *b0++;
+      sum += *window++ * *b0++;
+      sum -= *window++ * *b0++;
+
+      while(ntom >= NTOM_MUL) {
+        WRITE_SAMPLE(samples,sum,clip);
+        samples += step;
+        ntom -= NTOM_MUL;
+      }
+    }
+
+    ntom += ntom_step;
+    if(ntom >= NTOM_MUL)
+    {
+      real sum;
+      sum  = window[0x0] * b0[0x0];
+      sum += window[0x2] * b0[0x2];
+      sum += window[0x4] * b0[0x4];
+      sum += window[0x6] * b0[0x6];
+      sum += window[0x8] * b0[0x8];
+      sum += window[0xA] * b0[0xA];
+      sum += window[0xC] * b0[0xC];
+      sum += window[0xE] * b0[0xE];
+
+      while(ntom >= NTOM_MUL) {
+        WRITE_SAMPLE(samples,sum,clip);
+        samples += step;
+        ntom -= NTOM_MUL;
+      }
+    }
+
+    b0-=0x10,window-=0x20;
+    window += bo1<<1;
+
+    for (j=15;j;j--,b0-=0x20,window-=0x10)
+    {
+      real sum;
+
+      ntom += ntom_step;
+      if(ntom < NTOM_MUL) {
+        window -= 16;
+        b0 += 16;
+        continue;
+      }
+
+      sum = -*(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+      sum -= *(--window) * *b0++;
+
+      while(ntom >= NTOM_MUL) {
+        WRITE_SAMPLE(samples,sum,clip);
+        samples += step;
+        ntom -= NTOM_MUL;
+      }
+    }
+  }
+
+  ntom_val[channel] = ntom;
+  *pnt = ((unsigned char *) samples - out);
+
+  return clip;
+}
+
+
diff --git a/addons/mp3/huffman.h b/addons/mp3/huffman.h
new file mode 100644
index 000000000..7fec0d589
--- /dev/null
+++ b/addons/mp3/huffman.h
@@ -0,0 +1,332 @@
+/*
+ * huffman tables ... recalcualted to work with my optimzed
+ * decoder scheme (MH)
+ * 
+ * probably we could save a few bytes of memory, because the 
+ * smaller tables are often the part of a bigger table
+ */
+
+struct newhuff 
+{
+  unsigned int linbits;
+  short *table;
+};
+
+static short tab0[] = 
+{ 
+   0
+};
+
+static short tab1[] =
+{
+  -5,  -3,  -1,  17,   1,  16,   0
+};
+
+static short tab2[] =
+{
+ -15, -11,  -9,  -5,  -3,  -1,  34,   2,  18,  -1,  33,  32,  17,  -1,   1,
+  16,   0
+};
+
+static short tab3[] =
+{
+ -13, -11,  -9,  -5,  -3,  -1,  34,   2,  18,  -1,  33,  32,  16,  17,  -1,
+   1,   0
+};
+
+static short tab5[] =
+{
+ -29, -25, -23, -15,  -7,  -5,  -3,  -1,  51,  35,  50,  49,  -3,  -1,  19,
+   3,  -1,  48,  34,  -3,  -1,  18,  33,  -1,   2,  32,  17,  -1,   1,  16,
+   0
+};
+
+static short tab6[] =
+{
+ -25, -19, -13,  -9,  -5,  -3,  -1,  51,   3,  35,  -1,  50,  48,  -1,  19,
+  49,  -3,  -1,  34,   2,  18,  -3,  -1,  33,  32,   1,  -1,  17,  -1,  16,
+   0
+};
+
+static short tab7[] =
+{
+ -69, -65, -57, -39, -29, -17, -11,  -7,  -3,  -1,  85,  69,  -1,  84,  83,
+  -1,  53,  68,  -3,  -1,  37,  82,  21,  -5,  -1,  81,  -1,   5,  52,  -1,
+  80,  -1,  67,  51,  -5,  -3,  -1,  36,  66,  20,  -1,  65,  64, -11,  -7,
+  -3,  -1,   4,  35,  -1,  50,   3,  -1,  19,  49,  -3,  -1,  48,  34,  18,
+  -5,  -1,  33,  -1,   2,  32,  17,  -1,   1,  16,   0
+};
+
+static short tab8[] =
+{
+ -65, -63, -59, -45, -31, -19, -13,  -7,  -5,  -3,  -1,  85,  84,  69,  83,
+  -3,  -1,  53,  68,  37,  -3,  -1,  82,   5,  21,  -5,  -1,  81,  -1,  52,
+  67,  -3,  -1,  80,  51,  36,  -5,  -3,  -1,  66,  20,  65,  -3,  -1,   4,
+  64,  -1,  35,  50,  -9,  -7,  -3,  -1,  19,  49,  -1,   3,  48,  34,  -1,
+   2,  32,  -1,  18,  33,  17,  -3,  -1,   1,  16,   0
+};
+
+static short tab9[] =
+{
+ -63, -53, -41, -29, -19, -11,  -5,  -3,  -1,  85,  69,  53,  -1,  83,  -1,
+  84,   5,  -3,  -1,  68,  37,  -1,  82,  21,  -3,  -1,  81,  52,  -1,  67,
+  -1,  80,   4,  -7,  -3,  -1,  36,  66,  -1,  51,  64,  -1,  20,  65,  -5,
+  -3,  -1,  35,  50,  19,  -1,  49,  -1,   3,  48,  -5,  -3,  -1,  34,   2,
+  18,  -1,  33,  32,  -3,  -1,  17,   1,  -1,  16,   0
+};
+
+static short tab10[] =
+{
+-125,-121,-111, -83, -55, -35, -21, -13,  -7,  -3,  -1, 119, 103,  -1, 118,
+  87,  -3,  -1, 117, 102,  71,  -3,  -1, 116,  86,  -1, 101,  55,  -9,  -3,
+  -1, 115,  70,  -3,  -1,  85,  84,  99,  -1,  39, 114, -11,  -5,  -3,  -1,
+ 100,   7, 112,  -1,  98,  -1,  69,  53,  -5,  -1,   6,  -1,  83,  68,  23,
+ -17,  -5,  -1, 113,  -1,  54,  38,  -5,  -3,  -1,  37,  82,  21,  -1,  81,
+  -1,  52,  67,  -3,  -1,  22,  97,  -1,  96,  -1,   5,  80, -19, -11,  -7,
+  -3,  -1,  36,  66,  -1,  51,   4,  -1,  20,  65,  -3,  -1,  64,  35,  -1,
+  50,   3,  -3,  -1,  19,  49,  -1,  48,  34,  -7,  -3,  -1,  18,  33,  -1,
+   2,  32,  17,  -1,   1,  16,   0
+};
+
+static short tab11[] =
+{
+-121,-113, -89, -59, -43, -27, -17,  -7,  -3,  -1, 119, 103,  -1, 118, 117,
+  -3,  -1, 102,  71,  -1, 116,  -1,  87,  85,  -5,  -3,  -1,  86, 101,  55,
+  -1, 115,  70,  -9,  -7,  -3,  -1,  69,  84,  -1,  53,  83,  39,  -1, 114,
+  -1, 100,   7,  -5,  -1, 113,  -1,  23, 112,  -3,  -1,  54,  99,  -1,  96,
+  -1,  68,  37, -13,  -7,  -5,  -3,  -1,  82,   5,  21,  98,  -3,  -1,  38,
+   6,  22,  -5,  -1,  97,  -1,  81,  52,  -5,  -1,  80,  -1,  67,  51,  -1,
+  36,  66, -15, -11,  -7,  -3,  -1,  20,  65,  -1,   4,  64,  -1,  35,  50,
+  -1,  19,  49,  -5,  -3,  -1,   3,  48,  34,  33,  -5,  -1,  18,  -1,   2,
+  32,  17,  -3,  -1,   1,  16,   0
+};
+
+static short tab12[] =
+{
+-115, -99, -73, -45, -27, -17,  -9,  -5,  -3,  -1, 119, 103, 118,  -1,  87,
+ 117,  -3,  -1, 102,  71,  -1, 116, 101,  -3,  -1,  86,  55,  -3,  -1, 115,
+  85,  39,  -7,  -3,  -1, 114,  70,  -1, 100,  23,  -5,  -1, 113,  -1,   7,
+ 112,  -1,  54,  99, -13,  -9,  -3,  -1,  69,  84,  -1,  68,  -1,   6,   5,
+  -1,  38,  98,  -5,  -1,  97,  -1,  22,  96,  -3,  -1,  53,  83,  -1,  37,
+  82, -17,  -7,  -3,  -1,  21,  81,  -1,  52,  67,  -5,  -3,  -1,  80,   4,
+  36,  -1,  66,  20,  -3,  -1,  51,  65,  -1,  35,  50, -11,  -7,  -5,  -3,
+  -1,  64,   3,  48,  19,  -1,  49,  34,  -1,  18,  33,  -7,  -5,  -3,  -1,
+   2,  32,   0,  17,  -1,   1,  16
+};
+
+static short tab13[] =
+{
+-509,-503,-475,-405,-333,-265,-205,-153,-115, -83, -53, -35, -21, -13,  -9,
+  -7,  -5,  -3,  -1, 254, 252, 253, 237, 255,  -1, 239, 223,  -3,  -1, 238,
+ 207,  -1, 222, 191,  -9,  -3,  -1, 251, 206,  -1, 220,  -1, 175, 233,  -1,
+ 236, 221,  -9,  -5,  -3,  -1, 250, 205, 190,  -1, 235, 159,  -3,  -1, 249,
+ 234,  -1, 189, 219, -17,  -9,  -3,  -1, 143, 248,  -1, 204,  -1, 174, 158,
+  -5,  -1, 142,  -1, 127, 126, 247,  -5,  -1, 218,  -1, 173, 188,  -3,  -1,
+ 203, 246, 111, -15,  -7,  -3,  -1, 232,  95,  -1, 157, 217,  -3,  -1, 245,
+ 231,  -1, 172, 187,  -9,  -3,  -1,  79, 244,  -3,  -1, 202, 230, 243,  -1,
+  63,  -1, 141, 216, -21,  -9,  -3,  -1,  47, 242,  -3,  -1, 110, 156,  15,
+  -5,  -3,  -1, 201,  94, 171,  -3,  -1, 125, 215,  78, -11,  -5,  -3,  -1,
+ 200, 214,  62,  -1, 185,  -1, 155, 170,  -1,  31, 241, -23, -13,  -5,  -1,
+ 240,  -1, 186, 229,  -3,  -1, 228, 140,  -1, 109, 227,  -5,  -1, 226,  -1,
+  46,  14,  -1,  30, 225, -15,  -7,  -3,  -1, 224,  93,  -1, 213, 124,  -3,
+  -1, 199,  77,  -1, 139, 184,  -7,  -3,  -1, 212, 154,  -1, 169, 108,  -1,
+ 198,  61, -37, -21,  -9,  -5,  -3,  -1, 211, 123,  45,  -1, 210,  29,  -5,
+  -1, 183,  -1,  92, 197,  -3,  -1, 153, 122, 195,  -7,  -5,  -3,  -1, 167,
+ 151,  75, 209,  -3,  -1,  13, 208,  -1, 138, 168, -11,  -7,  -3,  -1,  76,
+ 196,  -1, 107, 182,  -1,  60,  44,  -3,  -1, 194,  91,  -3,  -1, 181, 137,
+  28, -43, -23, -11,  -5,  -1, 193,  -1, 152,  12,  -1, 192,  -1, 180, 106,
+  -5,  -3,  -1, 166, 121,  59,  -1, 179,  -1, 136,  90, -11,  -5,  -1,  43,
+  -1, 165, 105,  -1, 164,  -1, 120, 135,  -5,  -1, 148,  -1, 119, 118, 178,
+ -11,  -3,  -1,  27, 177,  -3,  -1,  11, 176,  -1, 150,  74,  -7,  -3,  -1,
+  58, 163,  -1,  89, 149,  -1,  42, 162, -47, -23,  -9,  -3,  -1,  26, 161,
+  -3,  -1,  10, 104, 160,  -5,  -3,  -1, 134,  73, 147,  -3,  -1,  57,  88,
+  -1, 133, 103,  -9,  -3,  -1,  41, 146,  -3,  -1,  87, 117,  56,  -5,  -1,
+ 131,  -1, 102,  71,  -3,  -1, 116,  86,  -1, 101, 115, -11,  -3,  -1,  25,
+ 145,  -3,  -1,   9, 144,  -1,  72, 132,  -7,  -5,  -1, 114,  -1,  70, 100,
+  40,  -1, 130,  24, -41, -27, -11,  -5,  -3,  -1,  55,  39,  23,  -1, 113,
+  -1,  85,   7,  -7,  -3,  -1, 112,  54,  -1,  99,  69,  -3,  -1,  84,  38,
+  -1,  98,  53,  -5,  -1, 129,  -1,   8, 128,  -3,  -1,  22,  97,  -1,   6,
+  96, -13,  -9,  -5,  -3,  -1,  83,  68,  37,  -1,  82,   5,  -1,  21,  81,
+  -7,  -3,  -1,  52,  67,  -1,  80,  36,  -3,  -1,  66,  51,  20, -19, -11,
+  -5,  -1,  65,  -1,   4,  64,  -3,  -1,  35,  50,  19,  -3,  -1,  49,   3,
+  -1,  48,  34,  -3,  -1,  18,  33,  -1,   2,  32,  -3,  -1,  17,   1,  16,
+   0
+};
+
+static short tab15[] =
+{
+-495,-445,-355,-263,-183,-115, -77, -43, -27, -13,  -7,  -3,  -1, 255, 239,
+  -1, 254, 223,  -1, 238,  -1, 253, 207,  -7,  -3,  -1, 252, 222,  -1, 237,
+ 191,  -1, 251,  -1, 206, 236,  -7,  -3,  -1, 221, 175,  -1, 250, 190,  -3,
+  -1, 235, 205,  -1, 220, 159, -15,  -7,  -3,  -1, 249, 234,  -1, 189, 219,
+  -3,  -1, 143, 248,  -1, 204, 158,  -7,  -3,  -1, 233, 127,  -1, 247, 173,
+  -3,  -1, 218, 188,  -1, 111,  -1, 174,  15, -19, -11,  -3,  -1, 203, 246,
+  -3,  -1, 142, 232,  -1,  95, 157,  -3,  -1, 245, 126,  -1, 231, 172,  -9,
+  -3,  -1, 202, 187,  -3,  -1, 217, 141,  79,  -3,  -1, 244,  63,  -1, 243,
+ 216, -33, -17,  -9,  -3,  -1, 230,  47,  -1, 242,  -1, 110, 240,  -3,  -1,
+  31, 241,  -1, 156, 201,  -7,  -3,  -1,  94, 171,  -1, 186, 229,  -3,  -1,
+ 125, 215,  -1,  78, 228, -15,  -7,  -3,  -1, 140, 200,  -1,  62, 109,  -3,
+  -1, 214, 227,  -1, 155, 185,  -7,  -3,  -1,  46, 170,  -1, 226,  30,  -5,
+  -1, 225,  -1,  14, 224,  -1,  93, 213, -45, -25, -13,  -7,  -3,  -1, 124,
+ 199,  -1,  77, 139,  -1, 212,  -1, 184, 154,  -7,  -3,  -1, 169, 108,  -1,
+ 198,  61,  -1, 211, 210,  -9,  -5,  -3,  -1,  45,  13,  29,  -1, 123, 183,
+  -5,  -1, 209,  -1,  92, 208,  -1, 197, 138, -17,  -7,  -3,  -1, 168,  76,
+  -1, 196, 107,  -5,  -1, 182,  -1, 153,  12,  -1,  60, 195,  -9,  -3,  -1,
+ 122, 167,  -1, 166,  -1, 192,  11,  -1, 194,  -1,  44,  91, -55, -29, -15,
+  -7,  -3,  -1, 181,  28,  -1, 137, 152,  -3,  -1, 193,  75,  -1, 180, 106,
+  -5,  -3,  -1,  59, 121, 179,  -3,  -1, 151, 136,  -1,  43,  90, -11,  -5,
+  -1, 178,  -1, 165,  27,  -1, 177,  -1, 176, 105,  -7,  -3,  -1, 150,  74,
+  -1, 164, 120,  -3,  -1, 135,  58, 163, -17,  -7,  -3,  -1,  89, 149,  -1,
+  42, 162,  -3,  -1,  26, 161,  -3,  -1,  10, 160, 104,  -7,  -3,  -1, 134,
+  73,  -1, 148,  57,  -5,  -1, 147,  -1, 119,   9,  -1,  88, 133, -53, -29,
+ -13,  -7,  -3,  -1,  41, 103,  -1, 118, 146,  -1, 145,  -1,  25, 144,  -7,
+  -3,  -1,  72, 132,  -1,  87, 117,  -3,  -1,  56, 131,  -1, 102,  71,  -7,
+  -3,  -1,  40, 130,  -1,  24, 129,  -7,  -3,  -1, 116,   8,  -1, 128,  86,
+  -3,  -1, 101,  55,  -1, 115,  70, -17,  -7,  -3,  -1,  39, 114,  -1, 100,
+  23,  -3,  -1,  85, 113,  -3,  -1,   7, 112,  54,  -7,  -3,  -1,  99,  69,
+  -1,  84,  38,  -3,  -1,  98,  22,  -3,  -1,   6,  96,  53, -33, -19,  -9,
+  -5,  -1,  97,  -1,  83,  68,  -1,  37,  82,  -3,  -1,  21,  81,  -3,  -1,
+   5,  80,  52,  -7,  -3,  -1,  67,  36,  -1,  66,  51,  -1,  65,  -1,  20,
+   4,  -9,  -3,  -1,  35,  50,  -3,  -1,  64,   3,  19,  -3,  -1,  49,  48,
+  34,  -9,  -7,  -3,  -1,  18,  33,  -1,   2,  32,  17,  -3,  -1,   1,  16,
+   0
+};
+
+static short tab16[] =
+{
+-509,-503,-461,-323,-103, -37, -27, -15,  -7,  -3,  -1, 239, 254,  -1, 223,
+ 253,  -3,  -1, 207, 252,  -1, 191, 251,  -5,  -1, 175,  -1, 250, 159,  -3,
+  -1, 249, 248, 143,  -7,  -3,  -1, 127, 247,  -1, 111, 246, 255,  -9,  -5,
+  -3,  -1,  95, 245,  79,  -1, 244, 243, -53,  -1, 240,  -1,  63, -29, -19,
+ -13,  -7,  -5,  -1, 206,  -1, 236, 221, 222,  -1, 233,  -1, 234, 217,  -1,
+ 238,  -1, 237, 235,  -3,  -1, 190, 205,  -3,  -1, 220, 219, 174, -11,  -5,
+  -1, 204,  -1, 173, 218,  -3,  -1, 126, 172, 202,  -5,  -3,  -1, 201, 125,
+  94, 189, 242, -93,  -5,  -3,  -1,  47,  15,  31,  -1, 241, -49, -25, -13,
+  -5,  -1, 158,  -1, 188, 203,  -3,  -1, 142, 232,  -1, 157, 231,  -7,  -3,
+  -1, 187, 141,  -1, 216, 110,  -1, 230, 156, -13,  -7,  -3,  -1, 171, 186,
+  -1, 229, 215,  -1,  78,  -1, 228, 140,  -3,  -1, 200,  62,  -1, 109,  -1,
+ 214, 155, -19, -11,  -5,  -3,  -1, 185, 170, 225,  -1, 212,  -1, 184, 169,
+  -5,  -1, 123,  -1, 183, 208, 227,  -7,  -3,  -1,  14, 224,  -1,  93, 213,
+  -3,  -1, 124, 199,  -1,  77, 139, -75, -45, -27, -13,  -7,  -3,  -1, 154,
+ 108,  -1, 198,  61,  -3,  -1,  92, 197,  13,  -7,  -3,  -1, 138, 168,  -1,
+ 153,  76,  -3,  -1, 182, 122,  60, -11,  -5,  -3,  -1,  91, 137,  28,  -1,
+ 192,  -1, 152, 121,  -1, 226,  -1,  46,  30, -15,  -7,  -3,  -1, 211,  45,
+  -1, 210, 209,  -5,  -1,  59,  -1, 151, 136,  29,  -7,  -3,  -1, 196, 107,
+  -1, 195, 167,  -1,  44,  -1, 194, 181, -23, -13,  -7,  -3,  -1, 193,  12,
+  -1,  75, 180,  -3,  -1, 106, 166, 179,  -5,  -3,  -1,  90, 165,  43,  -1,
+ 178,  27, -13,  -5,  -1, 177,  -1,  11, 176,  -3,  -1, 105, 150,  -1,  74,
+ 164,  -5,  -3,  -1, 120, 135, 163,  -3,  -1,  58,  89,  42, -97, -57, -33,
+ -19, -11,  -5,  -3,  -1, 149, 104, 161,  -3,  -1, 134, 119, 148,  -5,  -3,
+  -1,  73,  87, 103, 162,  -5,  -1,  26,  -1,  10, 160,  -3,  -1,  57, 147,
+  -1,  88, 133,  -9,  -3,  -1,  41, 146,  -3,  -1, 118,   9,  25,  -5,  -1,
+ 145,  -1, 144,  72,  -3,  -1, 132, 117,  -1,  56, 131, -21, -11,  -5,  -3,
+  -1, 102,  40, 130,  -3,  -1,  71, 116,  24,  -3,  -1, 129, 128,  -3,  -1,
+   8,  86,  55,  -9,  -5,  -1, 115,  -1, 101,  70,  -1,  39, 114,  -5,  -3,
+  -1, 100,  85,   7,  23, -23, -13,  -5,  -1, 113,  -1, 112,  54,  -3,  -1,
+  99,  69,  -1,  84,  38,  -3,  -1,  98,  22,  -1,  97,  -1,   6,  96,  -9,
+  -5,  -1,  83,  -1,  53,  68,  -1,  37,  82,  -1,  81,  -1,  21,   5, -33,
+ -23, -13,  -7,  -3,  -1,  52,  67,  -1,  80,  36,  -3,  -1,  66,  51,  20,
+  -5,  -1,  65,  -1,   4,  64,  -1,  35,  50,  -3,  -1,  19,  49,  -3,  -1,
+   3,  48,  34,  -3,  -1,  18,  33,  -1,   2,  32,  -3,  -1,  17,   1,  16,
+   0
+};
+
+static short tab24[] =
+{
+-451,-117, -43, -25, -15,  -7,  -3,  -1, 239, 254,  -1, 223, 253,  -3,  -1,
+ 207, 252,  -1, 191, 251,  -5,  -1, 250,  -1, 175, 159,  -1, 249, 248,  -9,
+  -5,  -3,  -1, 143, 127, 247,  -1, 111, 246,  -3,  -1,  95, 245,  -1,  79,
+ 244, -71,  -7,  -3,  -1,  63, 243,  -1,  47, 242,  -5,  -1, 241,  -1,  31,
+ 240, -25,  -9,  -1,  15,  -3,  -1, 238, 222,  -1, 237, 206,  -7,  -3,  -1,
+ 236, 221,  -1, 190, 235,  -3,  -1, 205, 220,  -1, 174, 234, -15,  -7,  -3,
+  -1, 189, 219,  -1, 204, 158,  -3,  -1, 233, 173,  -1, 218, 188,  -7,  -3,
+  -1, 203, 142,  -1, 232, 157,  -3,  -1, 217, 126,  -1, 231, 172, 255,-235,
+-143, -77, -45, -25, -15,  -7,  -3,  -1, 202, 187,  -1, 141, 216,  -5,  -3,
+  -1,  14, 224,  13, 230,  -5,  -3,  -1, 110, 156, 201,  -1,  94, 186,  -9,
+  -5,  -1, 229,  -1, 171, 125,  -1, 215, 228,  -3,  -1, 140, 200,  -3,  -1,
+  78,  46,  62, -15,  -7,  -3,  -1, 109, 214,  -1, 227, 155,  -3,  -1, 185,
+ 170,  -1, 226,  30,  -7,  -3,  -1, 225,  93,  -1, 213, 124,  -3,  -1, 199,
+  77,  -1, 139, 184, -31, -15,  -7,  -3,  -1, 212, 154,  -1, 169, 108,  -3,
+  -1, 198,  61,  -1, 211,  45,  -7,  -3,  -1, 210,  29,  -1, 123, 183,  -3,
+  -1, 209,  92,  -1, 197, 138, -17,  -7,  -3,  -1, 168, 153,  -1,  76, 196,
+  -3,  -1, 107, 182,  -3,  -1, 208,  12,  60,  -7,  -3,  -1, 195, 122,  -1,
+ 167,  44,  -3,  -1, 194,  91,  -1, 181,  28, -57, -35, -19,  -7,  -3,  -1,
+ 137, 152,  -1, 193,  75,  -5,  -3,  -1, 192,  11,  59,  -3,  -1, 176,  10,
+  26,  -5,  -1, 180,  -1, 106, 166,  -3,  -1, 121, 151,  -3,  -1, 160,   9,
+ 144,  -9,  -3,  -1, 179, 136,  -3,  -1,  43,  90, 178,  -7,  -3,  -1, 165,
+  27,  -1, 177, 105,  -1, 150, 164, -17,  -9,  -5,  -3,  -1,  74, 120, 135,
+  -1,  58, 163,  -3,  -1,  89, 149,  -1,  42, 162,  -7,  -3,  -1, 161, 104,
+  -1, 134, 119,  -3,  -1,  73, 148,  -1,  57, 147, -63, -31, -15,  -7,  -3,
+  -1,  88, 133,  -1,  41, 103,  -3,  -1, 118, 146,  -1,  25, 145,  -7,  -3,
+  -1,  72, 132,  -1,  87, 117,  -3,  -1,  56, 131,  -1, 102,  40, -17,  -7,
+  -3,  -1, 130,  24,  -1,  71, 116,  -5,  -1, 129,  -1,   8, 128,  -1,  86,
+ 101,  -7,  -5,  -1,  23,  -1,   7, 112, 115,  -3,  -1,  55,  39, 114, -15,
+  -7,  -3,  -1,  70, 100,  -1,  85, 113,  -3,  -1,  54,  99,  -1,  69,  84,
+  -7,  -3,  -1,  38,  98,  -1,  22,  97,  -5,  -3,  -1,   6,  96,  53,  -1,
+  83,  68, -51, -37, -23, -15,  -9,  -3,  -1,  37,  82,  -1,  21,  -1,   5,
+  80,  -1,  81,  -1,  52,  67,  -3,  -1,  36,  66,  -1,  51,  20,  -9,  -5,
+  -1,  65,  -1,   4,  64,  -1,  35,  50,  -1,  19,  49,  -7,  -5,  -3,  -1,
+   3,  48,  34,  18,  -1,  33,  -1,   2,  32,  -3,  -1,  17,   1,  -1,  16,
+   0
+};
+
+static short tab_c0[] =
+{
+ -29, -21, -13,  -7,  -3,  -1,  11,  15,  -1,  13,  14,  -3,  -1,   7,   5,
+   9,  -3,  -1,   6,   3,  -1,  10,  12,  -3,  -1,   2,   1,  -1,   4,   8,
+   0
+};
+
+static short tab_c1[] =
+{
+ -15,  -7,  -3,  -1,  15,  14,  -1,  13,  12,  -3,  -1,  11,  10,  -1,   9,
+   8,  -7,  -3,  -1,   7,   6,  -1,   5,   4,  -3,  -1,   3,   2,  -1,   1,
+   0
+};
+
+
+
+static struct newhuff ht[] = 
+{
+ { /* 0 */ 0 , tab0  } ,
+ { /* 2 */ 0 , tab1  } ,
+ { /* 3 */ 0 , tab2  } ,
+ { /* 3 */ 0 , tab3  } ,
+ { /* 0 */ 0 , tab0  } ,
+ { /* 4 */ 0 , tab5  } ,
+ { /* 4 */ 0 , tab6  } ,
+ { /* 6 */ 0 , tab7  } ,
+ { /* 6 */ 0 , tab8  } ,
+ { /* 6 */ 0 , tab9  } ,
+ { /* 8 */ 0 , tab10 } ,
+ { /* 8 */ 0 , tab11 } ,
+ { /* 8 */ 0 , tab12 } ,
+ { /* 16 */ 0 , tab13 } ,
+ { /* 0  */ 0 , tab0  } ,
+ { /* 16 */ 0 , tab15 } ,
+
+ { /* 16 */ 1 , tab16 } ,
+ { /* 16 */ 2 , tab16 } ,
+ { /* 16 */ 3 , tab16 } ,
+ { /* 16 */ 4 , tab16 } ,
+ { /* 16 */ 6 , tab16 } ,
+ { /* 16 */ 8 , tab16 } ,
+ { /* 16 */ 10, tab16 } ,
+ { /* 16 */ 13, tab16 } ,
+ { /* 16 */ 4 , tab24 } ,
+ { /* 16 */ 5 , tab24 } ,
+ { /* 16 */ 6 , tab24 } ,
+ { /* 16 */ 7 , tab24 } ,
+ { /* 16 */ 8 , tab24 } ,
+ { /* 16 */ 9 , tab24 } ,
+ { /* 16 */ 11, tab24 } ,
+ { /* 16 */ 13, tab24 }
+};
+
+static struct newhuff htc[] = 
+{
+ { /* 1 , 1 , */ 0 , tab_c0 } ,
+ { /* 1 , 1 , */ 0 , tab_c1 }
+};
+
+
diff --git a/addons/mp3/interface.c b/addons/mp3/interface.c
new file mode 100644
index 000000000..9ced53342
--- /dev/null
+++ b/addons/mp3/interface.c
@@ -0,0 +1,323 @@
+#include <asterisk.h>
+#include <asterisk/logger.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "mpg123.h"
+#include "mpglib.h"
+
+
+void InitMP3Constants(void)
+{
+	init_layer3_const();
+	make_decode_tables_const();
+	
+}
+
+
+BOOL InitMP3(struct mpstr *mp, long outscale) 
+{
+	/* quiet 4096 med 8192 */
+
+	memset(mp,0,sizeof(struct mpstr));
+
+	mp->framesize = 0;
+	mp->fsizeold = -1;
+	mp->bsize = 0;
+	mp->head = mp->tail = NULL;
+	mp->fr.single = 3; /* force mono */
+	mp->bsnum = 0;
+	mp->synth_bo = 1;
+	mp->outsamplerate = 8000;
+
+	make_decode_tables_scale(mp, outscale);
+
+	init_layer3_sample_limits(mp, SBLIMIT);
+
+	return !0;
+}
+
+void ExitMP3(struct mpstr *mp)
+{
+	struct buf *b,*bn;
+	
+	b = mp->tail;
+	while(b) {
+		free(b->pnt);
+		bn = b->next;
+		free(b);
+		b = bn;
+	}
+}
+
+static struct buf *addbuf(struct mpstr *mp,char *buf,int size)
+{
+	struct buf *nbuf;
+
+	nbuf = malloc( sizeof(struct buf) );
+	if(!nbuf) {
+		ast_log(LOG_WARNING,"Out of memory!\n");
+		return NULL;
+	}
+	nbuf->pnt = malloc(size);
+	if(!nbuf->pnt) {
+		free(nbuf);
+		return NULL;
+	}
+	nbuf->size = size;
+	memcpy(nbuf->pnt,buf,size);
+	nbuf->next = NULL;
+	nbuf->prev = mp->head;
+	nbuf->pos = 0;
+
+	if(!mp->tail) {
+		mp->tail = nbuf;
+	}
+	else {
+	  mp->head->next = nbuf;
+	}
+
+	mp->head = nbuf;
+	mp->bsize += size;
+
+	return nbuf;
+}
+
+static void remove_buf(struct mpstr *mp)
+{
+  struct buf *buf = mp->tail;
+  
+  mp->tail = buf->next;
+  if(mp->tail)
+    mp->tail->prev = NULL;
+  else {
+    mp->tail = mp->head = NULL;
+  }
+  
+  free(buf->pnt);
+  free(buf);
+
+}
+
+static int read_buf_byte(int *error, struct mpstr *mp)
+{
+	unsigned int b;int pos;
+
+	pos = mp->tail->pos;
+	while(pos >= mp->tail->size) {
+		remove_buf(mp);
+		pos = mp->tail->pos;
+		if(!mp->tail) {
+			/* We may pick up this error a few times*/
+			/* But things have gone pear shaped */
+			ast_log(LOG_WARNING,"Fatal Buffer error!\n");
+			*error = 1;
+			return (0);		
+		}
+	}
+
+	b = mp->tail->pnt[pos];
+	mp->bsize--;
+	mp->tail->pos++;
+	
+
+	return b;
+}
+
+static int  read_head(struct mpstr *mp)
+{
+	unsigned long head;
+	int error=0;
+	
+
+	head = read_buf_byte(&error, mp);
+	head <<= 8;
+	head |= read_buf_byte(&error, mp);
+	head <<= 8;
+	head |= read_buf_byte(&error, mp);
+	head <<= 8;
+	head |= read_buf_byte(&error, mp);
+
+	mp->header = head;
+
+	if(error){
+		return (1);
+	}else
+		return (0);
+		
+}
+
+static int head_check(unsigned long head)
+{
+    if( (head & 0xffe00000) != 0xffe00000)
+	return FALSE;
+    if(!((head>>17)&3))
+	return FALSE;
+    if( ((head>>12)&0xf) == 0xf || ((head>>12)&0xf) == 0)
+	return FALSE;
+    if( ((head>>10)&0x3) == 0x3 )
+	return FALSE;
+    if ((head & 0xffff0000) == 0xfffe0000)
+      return FALSE;
+
+    return TRUE;
+}
+
+static int head_shift(struct mpstr *mp)
+{
+	unsigned long head;
+	int error = 0;
+	
+	head = mp->header;
+	
+	head <<= 8;
+	head |= read_buf_byte(&error, mp);
+	
+	mp->header = head;
+
+	if (error){
+		return (1);
+	}else
+		return (0);
+	
+}
+
+
+int decodeMP3(struct mpstr *mp,char *in,int isize,char *out,
+		int osize,int *done)
+{
+	int len;
+	long n,m;
+	int down_sample_sblimit;
+
+	if(osize < 4608) {
+		ast_log(LOG_WARNING,"To less out space\n");
+		return MP3_ERR;
+	}
+
+	if(in) {
+		if(addbuf(mp,in,isize) == NULL) {
+			return MP3_ERR;
+		}
+	}
+
+	/* First decode header */
+	if(mp->framesize == 0) {
+		if(mp->bsize < 4) {
+			return MP3_NEED_MORE;
+		}
+		if (read_head(mp))
+			return MP3_ERR;
+		
+		if(!head_check(mp->header) ) {
+			int i;
+
+			ast_log(LOG_WARNING,"Junk at the beginning of frame %08lx\n",mp->header);
+			
+			/* step in byte steps through next 64K */
+			for(i=0;i<65536;i++) {
+				if(!mp->bsize)
+					return MP3_NEED_MORE;
+				
+				if(head_shift(mp))
+					return MP3_ERR;
+				
+				if(head_check(mp->header))
+					break;
+			}
+			if(i == 65536) {
+				ast_log(LOG_WARNING,"Giving up searching valid MPEG header\n");
+				return MP3_ERR;
+			}
+		}
+
+		decode_header(&mp->fr,mp->header);
+		mp->framesize = mp->fr.framesize;
+
+		if (!mp->initmp3){
+			mp->initmp3 = 1;
+			
+			n = freqs[mp->fr.sampling_frequency];
+			if (mp->outsamplerate) {
+				m = mp->outsamplerate;
+			}
+			else {
+				m =n;
+			}
+		
+			if (synth_ntom_set_step(n,m))
+				return MP3_ERR;
+			
+			
+			if(n>m) {
+				down_sample_sblimit = SBLIMIT * m;
+				down_sample_sblimit /= n;
+			}
+			else {
+				down_sample_sblimit = SBLIMIT;
+			}
+			
+			init_layer3_sample_limits(mp, down_sample_sblimit);
+	
+		}
+	}
+	
+
+	if(mp->fr.framesize > mp->bsize)
+		return MP3_NEED_MORE;
+
+	(mp->worksample).wordpointer = mp->bsspace[mp->bsnum] + 512;
+	mp->bsnum = (mp->bsnum + 1) & 0x1;
+	(mp->worksample).bitindex = 0;
+
+	len = 0;
+	while(len < mp->framesize) {
+		int nlen;
+		int blen = mp->tail->size - mp->tail->pos;
+		if( (mp->framesize - len) <= blen) {
+                  nlen = mp->framesize-len;
+		}
+		else {
+                  nlen = blen;
+                }
+		memcpy((mp->worksample).wordpointer+len,mp->tail->pnt+mp->tail->pos,nlen);
+                len += nlen;
+                mp->tail->pos += nlen;
+		mp->bsize -= nlen;
+                if(mp->tail->pos == mp->tail->size) {
+                   remove_buf(mp);
+                }
+	}
+
+	*done = 0;
+	if(mp->fr.error_protection)
+           getbits(mp, 16);
+	
+	if (do_layer3(mp,(unsigned char *) out,done))
+		return MP3_ERR;
+
+	mp->fsizeold = mp->framesize;
+	mp->framesize = 0;
+
+	return MP3_OK;
+}
+
+int set_pointer(struct mpstr *mp, long backstep)
+{
+  unsigned char *bsbufold;
+  if(mp->fsizeold < 0 && backstep > 0) {
+    ast_log(LOG_WARNING,"Can't step back %ld!\n",backstep);
+    return MP3_ERR;
+  }
+  bsbufold = mp->bsspace[mp->bsnum] + 512;
+  (mp->worksample).wordpointer -= backstep;
+  if (backstep)
+    memcpy((mp->worksample).wordpointer,bsbufold+mp->fsizeold-backstep,backstep);
+  (mp->worksample).bitindex = 0;
+  return MP3_OK;
+}
+
+
+
+
diff --git a/addons/mp3/layer3.c b/addons/mp3/layer3.c
new file mode 100644
index 000000000..793c99633
--- /dev/null
+++ b/addons/mp3/layer3.c
@@ -0,0 +1,2029 @@
+/* 
+ * Mpeg Layer-3 audio decoder 
+ * --------------------------
+ * copyright (c) 1995,1996,1997 by Michael Hipp.
+ * All rights reserved. See also 'README'
+ */ 
+
+#include <asterisk.h>
+#include <asterisk/logger.h>
+#include <stdlib.h>
+#include "mpg123.h"
+#include "mpglib.h"
+#include "huffman.h"
+
+#define MPEG1
+
+/* These should all be constants setup once using init_layer3_const */
+static real ispow[8207];
+static real aa_ca[8],aa_cs[8];
+static real COS1[12][6];
+static real win[4][36];
+static real win1[4][36];
+static real gainpow2[256+118+4];
+static real COS9[9];
+static real COS6_1,COS6_2;
+static real tfcos36[9];
+static real tfcos12[3];
+
+struct bandInfoStruct {
+  short longIdx[23];
+  short longDiff[22];
+  short shortIdx[14];
+  short shortDiff[13];
+};
+
+
+struct bandInfoStruct bandInfo[9] = { 
+
+/* MPEG 1.0 */
+ { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},
+   {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},
+   {0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3},
+   {4,4,4,4,6,8,10,12,14,18,22,30,56} } ,
+
+ { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},
+   {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},
+   {0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3},
+   {4,4,4,4,6,6,10,12,14,16,20,26,66} } ,
+
+ { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,
+   {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,
+   {0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} ,
+   {4,4,4,4,6,8,12,16,20,26,34,42,12} }  ,
+
+/* MPEG 2.0 */
+ { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
+   {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,
+   {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} ,
+   {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,
+
+ { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
+   {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } ,
+   {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} ,
+   {4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,
+
+ { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
+   {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },
+   {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3},
+   {4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,
+/* MPEG 2.5 */
+ { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
+   {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
+   {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
+   {4,4,4,6,8,10,12,14,18,24,30,40,18} },
+ { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
+   {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
+   {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
+   {4,4,4,6,8,10,12,14,18,24,30,40,18} },
+ { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},
+   {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2},
+   {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576},
+   {8,8,8,12,16,20,24,28,36,2,2,2,26} } ,
+};
+
+static int mapbuf0[9][152];
+static int mapbuf1[9][156];
+static int mapbuf2[9][44];
+static int *map[9][3];
+static int *mapend[9][3];
+
+static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */
+static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */
+
+static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16];
+static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16];
+
+/* 
+ * init constant tables for layer-3 
+ */
+void init_layer3_const(void)
+{
+  int i,j,k,l;
+
+  for(i=-256;i<118+4;i++)
+    gainpow2[i+256] = pow((double)2.0,-0.25 * (double) (i+210) );
+
+  for(i=0;i<8207;i++)
+    ispow[i] = pow((double)i,(double)4.0/3.0);
+
+  for (i=0;i<8;i++)
+  {
+    static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
+    double sq=sqrt(1.0+Ci[i]*Ci[i]);
+    aa_cs[i] = 1.0/sq;
+    aa_ca[i] = Ci[i]/sq;
+  }
+
+  for(i=0;i<18;i++)
+  {
+    win[0][i]    = win[1][i]    = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 );
+    win[0][i+18] = win[3][i+18] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
+  }
+  for(i=0;i<6;i++)
+  {
+    win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
+    win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 );
+    win[1][i+24] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 );
+    win[1][i+30] = win[3][i] = 0.0;
+    win[3][i+6 ] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) )  / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 );
+  }
+
+  for(i=0;i<9;i++)
+    COS9[i] = cos( M_PI / 18.0 * (double) i);
+
+  for(i=0;i<9;i++)
+    tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 );
+  for(i=0;i<3;i++)
+    tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 );
+
+  COS6_1 = cos( M_PI / 6.0 * (double) 1);
+  COS6_2 = cos( M_PI / 6.0 * (double) 2);
+
+  for(i=0;i<12;i++)
+  {
+    win[2][i]  = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 );
+    for(j=0;j<6;j++)
+      COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) );
+  }
+
+  for(j=0;j<4;j++) {
+    static int len[4] = { 36,36,12,36 };
+    for(i=0;i<len[j];i+=2)
+      win1[j][i] = + win[j][i];
+    for(i=1;i<len[j];i+=2)
+      win1[j][i] = - win[j][i];
+  }
+
+  for(i=0;i<16;i++)
+  {
+    double t = tan( (double) i * M_PI / 12.0 );
+    tan1_1[i] = t / (1.0+t);
+    tan2_1[i] = 1.0 / (1.0 + t);
+    tan1_2[i] = M_SQRT2 * t / (1.0+t);
+    tan2_2[i] = M_SQRT2 / (1.0 + t);
+
+    for(j=0;j<2;j++) {
+      double base = pow(2.0,-0.25*(j+1.0));
+      double p1=1.0,p2=1.0;
+      if(i > 0) {
+        if( i & 1 )
+          p1 = pow(base,(i+1.0)*0.5);
+        else
+          p2 = pow(base,i*0.5);
+      }
+      pow1_1[j][i] = p1;
+      pow2_1[j][i] = p2;
+      pow1_2[j][i] = M_SQRT2 * p1;
+      pow2_2[j][i] = M_SQRT2 * p2;
+    }
+  }
+
+  for(j=0;j<9;j++)
+  {
+   struct bandInfoStruct *bi = &bandInfo[j];
+   int *mp;
+   int cb,lwin;
+   short *bdf;
+
+   mp = map[j][0] = mapbuf0[j];
+   bdf = bi->longDiff;
+   for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) {
+     *mp++ = (*bdf) >> 1;
+     *mp++ = i;
+     *mp++ = 3;
+     *mp++ = cb;
+   }
+   bdf = bi->shortDiff+3;
+   for(cb=3;cb<13;cb++) {
+     int l = (*bdf++) >> 1;
+     for(lwin=0;lwin<3;lwin++) {
+       *mp++ = l;
+       *mp++ = i + lwin;
+       *mp++ = lwin;
+       *mp++ = cb;
+     }
+     i += 6*l;
+   }
+   mapend[j][0] = mp;
+
+   mp = map[j][1] = mapbuf1[j];
+   bdf = bi->shortDiff+0;
+   for(i=0,cb=0;cb<13;cb++) {
+     int l = (*bdf++) >> 1;
+     for(lwin=0;lwin<3;lwin++) {
+       *mp++ = l;
+       *mp++ = i + lwin;
+       *mp++ = lwin;
+       *mp++ = cb;
+     }
+     i += 6*l;
+   }
+   mapend[j][1] = mp;
+
+   mp = map[j][2] = mapbuf2[j];
+   bdf = bi->longDiff;
+   for(cb = 0; cb < 22 ; cb++) {
+     *mp++ = (*bdf++) >> 1;
+     *mp++ = cb;
+   }
+   mapend[j][2] = mp;
+
+  }
+
+  for(i=0;i<5;i++) {
+    for(j=0;j<6;j++) {
+      for(k=0;k<6;k++) {
+        int n = k + j * 6 + i * 36;
+        i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12);
+      }
+    }
+  }
+  for(i=0;i<4;i++) {
+    for(j=0;j<4;j++) {
+      for(k=0;k<4;k++) {
+        int n = k + j * 4 + i * 16;
+        i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12);
+      }
+    }
+  }
+  for(i=0;i<4;i++) {
+    for(j=0;j<3;j++) {
+      int n = j + i * 3;
+      i_slen2[n+244] = i|(j<<3) | (5<<12);
+      n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15);
+    }
+  }
+
+  for(i=0;i<5;i++) {
+    for(j=0;j<5;j++) {
+      for(k=0;k<4;k++) {
+        for(l=0;l<4;l++) {
+          int n = l + k * 4 + j * 16 + i * 80;
+          n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12);
+        }
+      }
+    }
+  }
+  for(i=0;i<5;i++) {
+    for(j=0;j<5;j++) {
+      for(k=0;k<4;k++) {
+        int n = k + j * 4 + i * 20;
+        n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12);
+      }
+    }
+  }
+}
+
+/* MP3 file specific rates */
+void init_layer3_sample_limits(struct mpstr *mp, int down_sample_sblimit)
+{
+	int i,j;	
+	for(j=0;j<9;j++) {
+		for(i=0;i<23;i++) {
+			(mp->longLimit)[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;
+			if((mp->longLimit)[j][i] > (down_sample_sblimit) )
+				(mp->longLimit)[j][i] = down_sample_sblimit;
+		}
+		for(i=0;i<14;i++) {
+			(mp->shortLimit)[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;
+			if((mp->shortLimit)[j][i] > (down_sample_sblimit) )
+				(mp->shortLimit)[j][i] = down_sample_sblimit;
+		}
+	}
+}
+
+
+
+/*
+ * read additional side information
+ */
+#ifdef MPEG1 
+static int III_get_side_info_1(struct mpstr *mp, struct III_sideinfo *si,int stereo,
+ int ms_stereo,long sfreq,int single)
+{
+   int ch, gr;
+   int powdiff = (single == 3) ? 4 : 0;
+
+   si->main_data_begin = getbits(mp, 9);
+   if (stereo == 1)
+     si->private_bits = getbits_fast(mp, 5);
+   else 
+     si->private_bits = getbits_fast(mp, 3);
+
+   for (ch=0; ch<stereo; ch++) {
+       si->ch[ch].gr[0].scfsi = -1;
+       si->ch[ch].gr[1].scfsi = getbits_fast(mp, 4);
+   }
+
+   for (gr=0; gr<2; gr++) 
+   {
+     for (ch=0; ch<stereo; ch++) 
+     {
+       register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
+
+       gr_info->part2_3_length = getbits(mp, 12);
+       gr_info->big_values = getbits_fast(mp, 9);
+       if(gr_info->big_values > 288) {
+          ast_log(LOG_WARNING,"big_values too large!\n");
+          gr_info->big_values = 288;
+       }
+       gr_info->pow2gain = gainpow2+256 - getbits_fast(mp, 8) + powdiff;
+       if(ms_stereo)
+         gr_info->pow2gain += 2;
+       gr_info->scalefac_compress = getbits_fast(mp, 4);
+/* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
+       if(get1bit(mp)) 
+       {
+         int i;
+         gr_info->block_type = getbits_fast(mp, 2);
+         gr_info->mixed_block_flag = get1bit(mp);
+         gr_info->table_select[0] = getbits_fast(mp, 5);
+         gr_info->table_select[1] = getbits_fast(mp, 5);
+         /*
+          * table_select[2] not needed, because there is no region2,
+          * but to satisfy some verifications tools we set it either.
+          */
+         gr_info->table_select[2] = 0;
+         for(i=0;i<3;i++)
+           gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(mp, 3)<<3);
+
+         if(gr_info->block_type == 0) {
+           ast_log(LOG_WARNING,"Blocktype == 0 and window-switching == 1 not allowed.\n");
+           return (1);
+         }
+         /* region_count/start parameters are implicit in this case. */       
+         gr_info->region1start = 36>>1;
+         gr_info->region2start = 576>>1;
+       }
+       else 
+       {
+         int i,r0c,r1c;
+         for (i=0; i<3; i++)
+           gr_info->table_select[i] = getbits_fast(mp, 5);
+         r0c = getbits_fast(mp, 4);
+         r1c = getbits_fast(mp, 3);
+         gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
+         gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
+         gr_info->block_type = 0;
+         gr_info->mixed_block_flag = 0;
+       }
+       gr_info->preflag = get1bit(mp);
+       gr_info->scalefac_scale = get1bit(mp);
+       gr_info->count1table_select = get1bit(mp);
+     }
+   }
+   return (0);
+   
+}
+#endif
+
+/*
+ * Side Info for MPEG 2.0 / LSF
+ */
+static int III_get_side_info_2(struct mpstr *mp, struct III_sideinfo *si,int stereo,
+ int ms_stereo,long sfreq,int single)
+{
+   int ch;
+   int powdiff = (single == 3) ? 4 : 0;
+
+   si->main_data_begin = getbits(mp, 8);
+   if (stereo == 1)
+     si->private_bits = get1bit(mp);
+   else 
+     si->private_bits = getbits_fast(mp, 2);
+
+   for (ch=0; ch<stereo; ch++) 
+   {
+       register struct gr_info_s *gr_info = &(si->ch[ch].gr[0]);
+
+       gr_info->part2_3_length = getbits(mp, 12);
+       gr_info->big_values = getbits_fast(mp, 9);
+       if(gr_info->big_values > 288) {
+         ast_log(LOG_WARNING,"big_values too large!\n");
+         gr_info->big_values = 288;
+       }
+       gr_info->pow2gain = gainpow2+256 - getbits_fast(mp, 8) + powdiff;
+       if(ms_stereo)
+         gr_info->pow2gain += 2;
+       gr_info->scalefac_compress = getbits(mp, 9);
+/* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
+       if(get1bit(mp)) 
+       {
+         int i;
+         gr_info->block_type = getbits_fast(mp, 2);
+         gr_info->mixed_block_flag = get1bit(mp);
+         gr_info->table_select[0] = getbits_fast(mp, 5);
+         gr_info->table_select[1] = getbits_fast(mp, 5);
+         /*
+          * table_select[2] not needed, because there is no region2,
+          * but to satisfy some verifications tools we set it either.
+          */
+         gr_info->table_select[2] = 0;
+         for(i=0;i<3;i++)
+           gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(mp, 3)<<3);
+
+         if(gr_info->block_type == 0) {
+           ast_log(LOG_WARNING,"Blocktype == 0 and window-switching == 1 not allowed.\n");
+           return (1);
+         }
+         /* region_count/start parameters are implicit in this case. */       
+/* check this again! */
+         if(gr_info->block_type == 2)
+           gr_info->region1start = 36>>1;
+         else if(sfreq == 8)
+/* check this for 2.5 and sfreq=8 */
+           gr_info->region1start = 108>>1;
+         else
+           gr_info->region1start = 54>>1;
+         gr_info->region2start = 576>>1;
+       }
+       else 
+       {
+         int i,r0c,r1c;
+         for (i=0; i<3; i++)
+           gr_info->table_select[i] = getbits_fast(mp, 5);
+         r0c = getbits_fast(mp, 4);
+         r1c = getbits_fast(mp, 3);
+         gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
+         gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
+         gr_info->block_type = 0;
+         gr_info->mixed_block_flag = 0;
+       }
+       gr_info->scalefac_scale = get1bit(mp);
+       gr_info->count1table_select = get1bit(mp);
+   }
+   return (0);
+}
+
+/*
+ * read scalefactors
+ */
+#ifdef MPEG1
+static int III_get_scale_factors_1(struct mpstr *mp, int *scf,struct gr_info_s *gr_info)
+{
+   static unsigned char slen[2][16] = {
+     {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
+     {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
+   };
+   int numbits;
+   int num0 = slen[0][gr_info->scalefac_compress];
+   int num1 = slen[1][gr_info->scalefac_compress];
+
+    if (gr_info->block_type == 2) 
+    {
+      int i=18;
+      numbits = (num0 + num1) * 18;
+
+      if (gr_info->mixed_block_flag) {
+         for (i=8;i;i--)
+           *scf++ = getbits_fast(mp, num0);
+         i = 9;
+         numbits -= num0; /* num0 * 17 + num1 * 18 */
+      }
+
+      for (;i;i--)
+        *scf++ = getbits_fast(mp, num0);
+      for (i = 18; i; i--)
+        *scf++ = getbits_fast(mp, num1);
+      *scf++ = 0; *scf++ = 0; *scf++ = 0; /* short[13][0..2] = 0 */
+    }
+    else 
+    {
+      int i;
+      int scfsi = gr_info->scfsi;
+
+      if(scfsi < 0) { /* scfsi < 0 => granule == 0 */
+         for(i=11;i;i--)
+           *scf++ = getbits_fast(mp, num0);
+         for(i=10;i;i--)
+           *scf++ = getbits_fast(mp, num1);
+         numbits = (num0 + num1) * 10 + num0;
+      }
+      else {
+        numbits = 0;
+        if(!(scfsi & 0x8)) {
+          for (i=6;i;i--)
+            *scf++ = getbits_fast(mp, num0);
+          numbits += num0 * 6;
+        }
+        else {
+          *scf++ = 0; *scf++ = 0; *scf++ = 0;  /* set to ZERO necessary? */
+          *scf++ = 0; *scf++ = 0; *scf++ = 0;
+        }
+
+        if(!(scfsi & 0x4)) {
+          for (i=5;i;i--)
+            *scf++ = getbits_fast(mp, num0);
+          numbits += num0 * 5;
+        }
+        else {
+          *scf++ = 0; *scf++ = 0; *scf++ = 0;  /* set to ZERO necessary? */
+          *scf++ = 0; *scf++ = 0;
+        }
+
+        if(!(scfsi & 0x2)) {
+          for(i=5;i;i--)
+            *scf++ = getbits_fast(mp, num1);
+          numbits += num1 * 5;
+        }
+        else {
+          *scf++ = 0; *scf++ = 0; *scf++ = 0;  /* set to ZERO necessary? */
+          *scf++ = 0; *scf++ = 0;
+        }
+
+        if(!(scfsi & 0x1)) {
+          for (i=5;i;i--)
+            *scf++ = getbits_fast(mp, num1);
+          numbits += num1 * 5;
+        }
+        else {
+          *scf++ = 0; *scf++ = 0; *scf++ = 0;  /* set to ZERO necessary? */
+          *scf++ = 0; *scf++ = 0;
+        }
+      }
+
+      *scf++ = 0;  /* no l[21] in original sources */
+    }
+    return numbits;
+}
+#endif
+
+static int III_get_scale_factors_2(struct mpstr *mp, int *scf,struct gr_info_s *gr_info,int i_stereo)
+{
+  unsigned char *pnt;
+  int i,j;
+  unsigned int slen;
+  int n = 0;
+  int numbits = 0;
+
+  static unsigned char stab[3][6][4] = {
+   { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
+     { 7, 7, 7,0 } , { 6, 6, 6,3 } , {  8, 8,5,0} } ,
+   { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
+     {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
+   { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
+     { 6,15,12,0 } , { 6,12, 9,6 } , {  6,18,9,0} } }; 
+
+  if(i_stereo) /* i_stereo AND second channel -> do_layer3() checks this */
+    slen = i_slen2[gr_info->scalefac_compress>>1];
+  else
+    slen = n_slen2[gr_info->scalefac_compress];
+
+  gr_info->preflag = (slen>>15) & 0x1;
+
+  n = 0;  
+  if( gr_info->block_type == 2 ) {
+    n++;
+    if(gr_info->mixed_block_flag)
+      n++;
+  }
+
+  pnt = stab[n][(slen>>12)&0x7];
+
+  for(i=0;i<4;i++) {
+    int num = slen & 0x7;
+    slen >>= 3;
+    if(num) {
+      for(j=0;j<(int)(pnt[i]);j++)
+        *scf++ = getbits_fast(mp, num);
+      numbits += pnt[i] * num;
+    }
+    else {
+      for(j=0;j<(int)(pnt[i]);j++)
+        *scf++ = 0;
+    }
+  }
+  
+  n = (n << 1) + 1;
+  for(i=0;i<n;i++)
+    *scf++ = 0;
+
+  return numbits;
+}
+
+static int pretab1[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
+static int pretab2[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+/*
+ * don't forget to apply the same changes to III_dequantize_sample_ms() !!! 
+ */
+static int III_dequantize_sample(struct mpstr *mp, real xr[SBLIMIT][SSLIMIT],int *scf,
+   struct gr_info_s *gr_info,int sfreq,int part2bits)
+{
+  int shift = 1 + gr_info->scalefac_scale;
+  real *xrpnt = (real *) xr;
+  int l[3],l3;
+  int part2remain = gr_info->part2_3_length - part2bits;
+  int *me;
+
+  {
+    int bv       = gr_info->big_values;
+    int region1  = gr_info->region1start;
+    int region2  = gr_info->region2start;
+
+    l3 = ((576>>1)-bv)>>1;   
+/*
+ * we may lose the 'odd' bit here !! 
+ * check this later again 
+ */
+    if(bv <= region1) {
+      l[0] = bv; l[1] = 0; l[2] = 0;
+    }
+    else {
+      l[0] = region1;
+      if(bv <= region2) {
+        l[1] = bv - l[0];  l[2] = 0;
+      }
+      else {
+        l[1] = region2 - l[0]; l[2] = bv - region2;
+      }
+    }
+  }
+ 
+  if(gr_info->block_type == 2) {
+    /*
+     * decoding with short or mixed mode BandIndex table 
+     */
+    int i,max[4];
+    int step=0,lwin=0,cb=0;
+    register real v = 0.0;
+    register int *m,mc;
+
+    if(gr_info->mixed_block_flag) {
+      max[3] = -1;
+      max[0] = max[1] = max[2] = 2;
+      m = map[sfreq][0];
+      me = mapend[sfreq][0];
+    }
+    else {
+      max[0] = max[1] = max[2] = max[3] = -1;
+      /* max[3] not really needed in this case */
+      m = map[sfreq][1];
+      me = mapend[sfreq][1];
+    }
+
+    mc = 0;
+    for(i=0;i<2;i++) {
+      int lp = l[i];
+      struct newhuff *h = ht+gr_info->table_select[i];
+      for(;lp;lp--,mc--) {
+        register int x,y;
+        if( (!mc) ) {
+          mc = *m++;
+          xrpnt = ((real *) xr) + (*m++);
+          lwin = *m++;
+          cb = *m++;
+          if(lwin == 3) {
+            v = gr_info->pow2gain[(*scf++) << shift];
+            step = 1;
+          }
+          else {
+            v = gr_info->full_gain[lwin][(*scf++) << shift];
+            step = 3;
+          }
+        }
+        {
+          register short *val = h->table;
+          while((y=*val++)<0) {
+            if (get1bit(mp))
+              val -= y;
+            part2remain--;
+          }
+          x = y >> 4;
+          y &= 0xf;
+        }
+        if(x == 15) {
+          max[lwin] = cb;
+          part2remain -= h->linbits+1;
+          x += getbits(mp, h->linbits);
+          if(get1bit(mp))
+            *xrpnt = -ispow[x] * v;
+          else
+            *xrpnt =  ispow[x] * v;
+        }
+        else if(x) {
+          max[lwin] = cb;
+          if(get1bit(mp))
+            *xrpnt = -ispow[x] * v;
+          else
+            *xrpnt =  ispow[x] * v;
+          part2remain--;
+        }
+        else
+          *xrpnt = 0.0;
+        xrpnt += step;
+        if(y == 15) {
+          max[lwin] = cb;
+          part2remain -= h->linbits+1;
+          y += getbits(mp, h->linbits);
+          if(get1bit(mp))
+            *xrpnt = -ispow[y] * v;
+          else
+            *xrpnt =  ispow[y] * v;
+        }
+        else if(y) {
+          max[lwin] = cb;
+          if(get1bit(mp))
+            *xrpnt = -ispow[y] * v;
+          else
+            *xrpnt =  ispow[y] * v;
+          part2remain--;
+        }
+        else
+          *xrpnt = 0.0;
+        xrpnt += step;
+      }
+    }
+    for(;l3 && (part2remain > 0);l3--) {
+      struct newhuff *h = htc+gr_info->count1table_select;
+      register short *val = h->table,a;
+
+      while((a=*val++)<0) {
+        part2remain--;
+        if(part2remain < 0) {
+          part2remain++;
+          a = 0;
+          break;
+        }
+        if (get1bit(mp))
+          val -= a;
+      }
+
+      for(i=0;i<4;i++) {
+        if(!(i & 1)) {
+          if(!mc) {
+            mc = *m++;
+            xrpnt = ((real *) xr) + (*m++);
+            lwin = *m++;
+            cb = *m++;
+            if(lwin == 3) {
+              v = gr_info->pow2gain[(*scf++) << shift];
+              step = 1;
+            }
+            else {
+              v = gr_info->full_gain[lwin][(*scf++) << shift];
+              step = 3;
+            }
+          }
+          mc--;
+        }
+        if( (a & (0x8>>i)) ) {
+          max[lwin] = cb;
+          part2remain--;
+          if(part2remain < 0) {
+            part2remain++;
+            break;
+          }
+          if(get1bit(mp)) 
+            *xrpnt = -v;
+          else
+            *xrpnt = v;
+        }
+        else
+          *xrpnt = 0.0;
+        xrpnt += step;
+      }
+    }
+ 
+    while( m < me ) {
+      if(!mc) {
+        mc = *m++;
+        xrpnt = ((real *) xr) + *m++;
+        if( (*m++) == 3)
+          step = 1;
+        else
+          step = 3;
+        m++; /* cb */
+      }
+      mc--;
+      *xrpnt = 0.0;
+      xrpnt += step;
+      *xrpnt = 0.0;
+      xrpnt += step;
+/* we could add a little opt. here:
+ * if we finished a band for window 3 or a long band
+ * further bands could copied in a simple loop without a
+ * special 'map' decoding
+ */
+    }
+
+    gr_info->maxband[0] = max[0]+1;
+    gr_info->maxband[1] = max[1]+1;
+    gr_info->maxband[2] = max[2]+1;
+    gr_info->maxbandl = max[3]+1;
+
+    {
+      int rmax = max[0] > max[1] ? max[0] : max[1];
+      rmax = (rmax > max[2] ? rmax : max[2]) + 1;
+      gr_info->maxb = rmax ? (mp->shortLimit)[sfreq][rmax] : (mp->longLimit)[sfreq][max[3]+1];
+    }
+
+  }
+  else {
+	/*
+     * decoding with 'long' BandIndex table (block_type != 2)
+     */
+    int *pretab = gr_info->preflag ? pretab1 : pretab2;
+    int i,max = -1;
+    int cb = 0;
+    register int *m = map[sfreq][2];
+    register real v = 0.0;
+    register int mc = 0;
+#if 0
+    me = mapend[sfreq][2];
+#endif
+
+	/*
+     * long hash table values
+     */
+    for(i=0;i<3;i++) {
+      int lp = l[i];
+      struct newhuff *h = ht+gr_info->table_select[i];
+
+      for(;lp;lp--,mc--) {
+        int x,y;
+
+        if(!mc) {
+          mc = *m++;
+          v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
+          cb = *m++;
+        }
+        {
+          register short *val = h->table;
+          while((y=*val++)<0) {
+            if (get1bit(mp))
+              val -= y;
+            part2remain--;
+          }
+          x = y >> 4;
+          y &= 0xf;
+        }
+        if (x == 15) {
+          max = cb;
+          part2remain -= h->linbits+1;
+          x += getbits(mp, h->linbits);
+          if(get1bit(mp))
+            *xrpnt++ = -ispow[x] * v;
+          else
+            *xrpnt++ =  ispow[x] * v;
+        }
+        else if(x) {
+          max = cb;
+          if(get1bit(mp))
+            *xrpnt++ = -ispow[x] * v;
+          else
+            *xrpnt++ =  ispow[x] * v;
+          part2remain--;
+        }
+        else
+          *xrpnt++ = 0.0;
+
+        if (y == 15) {
+          max = cb;
+          part2remain -= h->linbits+1;
+          y += getbits(mp, h->linbits);
+          if(get1bit(mp))
+            *xrpnt++ = -ispow[y] * v;
+          else
+            *xrpnt++ =  ispow[y] * v;
+        }
+        else if(y) {
+          max = cb;
+          if(get1bit(mp))
+            *xrpnt++ = -ispow[y] * v;
+          else
+            *xrpnt++ =  ispow[y] * v;
+          part2remain--;
+        }
+        else
+          *xrpnt++ = 0.0;
+      }
+    }
+
+	/*
+     * short (count1table) values
+     */
+    for(;l3 && (part2remain > 0);l3--) {
+      struct newhuff *h = htc+gr_info->count1table_select;
+      register short *val = h->table,a;
+
+      while((a=*val++)<0) {
+        part2remain--;
+        if(part2remain < 0) {
+          part2remain++;
+          a = 0;
+          break;
+        }
+        if (get1bit(mp))
+          val -= a;
+      }
+
+      for(i=0;i<4;i++) {
+        if(!(i & 1)) {
+          if(!mc) {
+            mc = *m++;
+            cb = *m++;
+            v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
+          }
+          mc--;
+        }
+        if ( (a & (0x8>>i)) ) {
+          max = cb;
+          part2remain--;
+          if(part2remain < 0) {
+            part2remain++;
+            break;
+          }
+          if(get1bit(mp))
+            *xrpnt++ = -v;
+          else
+            *xrpnt++ = v;
+        }
+        else
+          *xrpnt++ = 0.0;
+      }
+    }
+
+	/* 
+     * zero part
+     */
+    for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i;i--) {
+      *xrpnt++ = 0.0;
+      *xrpnt++ = 0.0;
+    }
+
+    gr_info->maxbandl = max+1;
+    gr_info->maxb = (mp->longLimit)[sfreq][gr_info->maxbandl];
+  }
+
+  while( part2remain > 16 ) {
+    getbits(mp, 16); /* Dismiss stuffing Bits */
+    part2remain -= 16;
+  }
+  if(part2remain > 0)
+    getbits(mp, part2remain);
+  else if(part2remain < 0) {
+    ast_log(LOG_WARNING,"mpg123: Can't rewind stream by %d bits!\n",-part2remain);
+    return 1; /* -> error */
+  }
+  return 0;
+}
+
+#if 0
+static int III_dequantize_sample_ms(real xr[2][SBLIMIT][SSLIMIT],int *scf,
+   struct gr_info_s *gr_info,int sfreq,int part2bits)
+{
+  int shift = 1 + gr_info->scalefac_scale;
+  real *xrpnt = (real *) xr[1];
+  real *xr0pnt = (real *) xr[0];
+  int l[3],l3;
+  int part2remain = gr_info->part2_3_length - part2bits;
+  int *me;
+
+  {
+    int bv       = gr_info->big_values;
+    int region1  = gr_info->region1start;
+    int region2  = gr_info->region2start;
+
+    l3 = ((576>>1)-bv)>>1;   
+/*
+ * we may lose the 'odd' bit here !! 
+ * check this later gain 
+ */
+    if(bv <= region1) {
+      l[0] = bv; l[1] = 0; l[2] = 0;
+    }
+    else {
+      l[0] = region1;
+      if(bv <= region2) {
+        l[1] = bv - l[0];  l[2] = 0;
+      }
+      else {
+        l[1] = region2 - l[0]; l[2] = bv - region2;
+      }
+    }
+  }
+ 
+  if(gr_info->block_type == 2) {
+    int i,max[4];
+    int step=0,lwin=0,cb=0;
+    register real v = 0.0;
+    register int *m,mc = 0;
+
+    if(gr_info->mixed_block_flag) {
+      max[3] = -1;
+      max[0] = max[1] = max[2] = 2;
+      m = map[sfreq][0];
+      me = mapend[sfreq][0];
+    }
+    else {
+      max[0] = max[1] = max[2] = max[3] = -1;
+      /* max[3] not really needed in this case */
+      m = map[sfreq][1];
+      me = mapend[sfreq][1];
+    }
+
+    for(i=0;i<2;i++) {
+      int lp = l[i];
+      struct newhuff *h = ht+gr_info->table_select[i];
+      for(;lp;lp--,mc--) {
+        int x,y;
+
+        if(!mc) {
+          mc = *m++;
+          xrpnt = ((real *) xr[1]) + *m;
+          xr0pnt = ((real *) xr[0]) + *m++;
+          lwin = *m++;
+          cb = *m++;
+          if(lwin == 3) {
+            v = gr_info->pow2gain[(*scf++) << shift];
+            step = 1;
+          }
+          else {
+            v = gr_info->full_gain[lwin][(*scf++) << shift];
+            step = 3;
+          }
+        }
+        {
+          register short *val = h->table;
+          while((y=*val++)<0) {
+            if (get1bit(mp))
+              val -= y;
+            part2remain--;
+          }
+          x = y >> 4;
+          y &= 0xf;
+        }
+        if(x == 15) {
+          max[lwin] = cb;
+          part2remain -= h->linbits+1;
+          x += getbits(mp, h->linbits);
+          if(get1bit(mp)) {
+            real a = ispow[x] * v;
+            *xrpnt = *xr0pnt + a;
+            *xr0pnt -= a;
+          }
+          else {
+            real a = ispow[x] * v;
+            *xrpnt = *xr0pnt - a;
+            *xr0pnt += a;
+          }
+        }
+        else if(x) {
+          max[lwin] = cb;
+          if(get1bit(mp)) {
+            real a = ispow[x] * v;
+            *xrpnt = *xr0pnt + a;
+            *xr0pnt -= a;
+          }
+          else {
+            real a = ispow[x] * v;
+            *xrpnt = *xr0pnt - a;
+            *xr0pnt += a;
+          }
+          part2remain--;
+        }
+        else
+          *xrpnt = *xr0pnt;
+        xrpnt += step;
+        xr0pnt += step;
+
+        if(y == 15) {
+          max[lwin] = cb;
+          part2remain -= h->linbits+1;
+          y += getbits(mp, h->linbits);
+          if(get1bit(mp)) {
+            real a = ispow[y] * v;
+            *xrpnt = *xr0pnt + a;
+            *xr0pnt -= a;
+          }
+          else {
+            real a = ispow[y] * v;
+            *xrpnt = *xr0pnt - a;
+            *xr0pnt += a;
+          }
+        }
+        else if(y) {
+          max[lwin] = cb;
+          if(get1bit(mp)) {
+            real a = ispow[y] * v;
+            *xrpnt = *xr0pnt + a;
+            *xr0pnt -= a;
+          }
+          else {
+            real a = ispow[y] * v;
+            *xrpnt = *xr0pnt - a;
+            *xr0pnt += a;
+          }
+          part2remain--;
+        }
+        else
+          *xrpnt = *xr0pnt;
+        xrpnt += step;
+        xr0pnt += step;
+      }
+    }
+
+    for(;l3 && (part2remain > 0);l3--) {
+      struct newhuff *h = htc+gr_info->count1table_select;
+      register short *val = h->table,a;
+
+      while((a=*val++)<0) {
+        part2remain--;
+        if(part2remain < 0) {
+          part2remain++;
+          a = 0;
+          break;
+        }
+        if (get1bit(mp))
+          val -= a;
+      }
+
+      for(i=0;i<4;i++) {
+        if(!(i & 1)) {
+          if(!mc) {
+            mc = *m++;
+            xrpnt = ((real *) xr[1]) + *m;
+            xr0pnt = ((real *) xr[0]) + *m++;
+            lwin = *m++;
+            cb = *m++;
+            if(lwin == 3) {
+              v = gr_info->pow2gain[(*scf++) << shift];
+              step = 1;
+            }
+            else {
+              v = gr_info->full_gain[lwin][(*scf++) << shift];
+              step = 3;
+            }
+          }
+          mc--;
+        }
+        if( (a & (0x8>>i)) ) {
+          max[lwin] = cb;
+          part2remain--;
+          if(part2remain < 0) {
+            part2remain++;
+            break;
+          }
+          if(get1bit(mp)) {
+            *xrpnt = *xr0pnt + v;
+            *xr0pnt -= v;
+          }
+          else {
+            *xrpnt = *xr0pnt - v;
+            *xr0pnt += v;
+          }
+        }
+        else
+          *xrpnt = *xr0pnt;
+        xrpnt += step;
+        xr0pnt += step;
+      }
+    }
+ 
+    while( m < me ) {
+      if(!mc) {
+        mc = *m++;
+        xrpnt = ((real *) xr[1]) + *m;
+        xr0pnt = ((real *) xr[0]) + *m++;
+        if(*m++ == 3)
+          step = 1;
+        else
+          step = 3;
+        m++; /* cb */
+      }
+      mc--;
+      *xrpnt = *xr0pnt;
+      xrpnt += step;
+      xr0pnt += step;
+      *xrpnt = *xr0pnt;
+      xrpnt += step;
+      xr0pnt += step;
+/* we could add a little opt. here:
+ * if we finished a band for window 3 or a long band
+ * further bands could copied in a simple loop without a
+ * special 'map' decoding
+ */
+    }
+
+    gr_info->maxband[0] = max[0]+1;
+    gr_info->maxband[1] = max[1]+1;
+    gr_info->maxband[2] = max[2]+1;
+    gr_info->maxbandl = max[3]+1;
+
+    {
+      int rmax = max[0] > max[1] ? max[0] : max[1];
+      rmax = (rmax > max[2] ? rmax : max[2]) + 1;
+      gr_info->maxb = rmax ? (mp->shortLimit)[sfreq][rmax] : (mp->longLimit)[sfreq][max[3]+1];
+    }
+  }
+  else {
+    int *pretab = gr_info->preflag ? pretab1 : pretab2;
+    int i,max = -1;
+    int cb = 0;
+    register int mc=0,*m = map[sfreq][2];
+    register real v = 0.0;
+#if 0
+    me = mapend[sfreq][2];
+#endif
+
+    for(i=0;i<3;i++) {
+      int lp = l[i];
+      struct newhuff *h = ht+gr_info->table_select[i];
+
+      for(;lp;lp--,mc--) {
+        int x,y;
+        if(!mc) {
+          mc = *m++;
+          cb = *m++;
+          v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
+        }
+        {
+          register short *val = h->table;
+          while((y=*val++)<0) {
+            if (get1bit(mp))
+              val -= y;
+            part2remain--;
+          }
+          x = y >> 4;
+          y &= 0xf;
+        }
+        if (x == 15) {
+          max = cb;
+          part2remain -= h->linbits+1;
+          x += getbits(mp, h->linbits);
+          if(get1bit(mp)) {
+            real a = ispow[x] * v;
+            *xrpnt++ = *xr0pnt + a;
+            *xr0pnt++ -= a;
+          }
+          else {
+            real a = ispow[x] * v;
+            *xrpnt++ = *xr0pnt - a;
+            *xr0pnt++ += a;
+          }
+        }
+        else if(x) {
+          max = cb;
+          if(get1bit(mp)) {
+            real a = ispow[x] * v;
+            *xrpnt++ = *xr0pnt + a;
+            *xr0pnt++ -= a;
+          }
+          else {
+            real a = ispow[x] * v;
+            *xrpnt++ = *xr0pnt - a;
+            *xr0pnt++ += a;
+          }
+          part2remain--;
+        }
+        else
+          *xrpnt++ = *xr0pnt++;
+
+        if (y == 15) {
+          max = cb;
+          part2remain -= h->linbits+1;
+          y += getbits(mp, h->linbits);
+          if(get1bit(mp)) {
+            real a = ispow[y] * v;
+            *xrpnt++ = *xr0pnt + a;
+            *xr0pnt++ -= a;
+          }
+          else {
+            real a = ispow[y] * v;
+            *xrpnt++ = *xr0pnt - a;
+            *xr0pnt++ += a;
+          }
+        }
+        else if(y) {
+          max = cb;
+          if(get1bit(mp)) {
+            real a = ispow[y] * v;
+            *xrpnt++ = *xr0pnt + a;
+            *xr0pnt++ -= a;
+          }
+          else {
+            real a = ispow[y] * v;
+            *xrpnt++ = *xr0pnt - a;
+            *xr0pnt++ += a;
+          }
+          part2remain--;
+        }
+        else
+          *xrpnt++ = *xr0pnt++;
+      }
+    }
+
+    for(;l3 && (part2remain > 0);l3--) {
+      struct newhuff *h = htc+gr_info->count1table_select;
+      register short *val = h->table,a;
+
+      while((a=*val++)<0) {
+        part2remain--;
+        if(part2remain < 0) {
+          part2remain++;
+          a = 0;
+          break;
+        }
+        if (get1bit(mp))
+          val -= a;
+      }
+
+      for(i=0;i<4;i++) {
+        if(!(i & 1)) {
+          if(!mc) {
+            mc = *m++;
+            cb = *m++;
+            v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
+          }
+          mc--;
+        }
+        if ( (a & (0x8>>i)) ) {
+          max = cb;
+          part2remain--;
+          if(part2remain <= 0) {
+            part2remain++;
+            break;
+          }
+          if(get1bit(mp)) {
+            *xrpnt++ = *xr0pnt + v;
+            *xr0pnt++ -= v;
+          }
+          else {
+            *xrpnt++ = *xr0pnt - v;
+            *xr0pnt++ += v;
+          }
+        }
+        else
+          *xrpnt++ = *xr0pnt++;
+      }
+    }
+    for(i=(&xr[1][SBLIMIT][0]-xrpnt)>>1;i;i--) {
+      *xrpnt++ = *xr0pnt++;
+      *xrpnt++ = *xr0pnt++;
+    }
+
+    gr_info->maxbandl = max+1;
+    gr_info->maxb = longLimit[sfreq][gr_info->maxbandl];
+  }
+
+  while ( part2remain > 16 ) {
+    getbits(mp, 16); /* Dismiss stuffing Bits */
+    part2remain -= 16;
+  }
+  if(part2remain > 0 )
+    getbits(mp, part2remain);
+  else if(part2remain < 0) {
+    ast_log(LOG_WARNING,"mpg123_ms: Can't rewind stream by %d bits!\n",-part2remain);
+    return 1; /* -> error */
+  }
+  return 0;
+}
+#endif
+
+/* 
+ * III_stereo: calculate real channel values for Joint-I-Stereo-mode
+ */
+static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac,
+   struct gr_info_s *gr_info,int sfreq,int ms_stereo,int lsf)
+{
+      real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf;
+      struct bandInfoStruct *bi = &bandInfo[sfreq];
+      real *tab1,*tab2;
+
+      if(lsf) {
+        int p = gr_info->scalefac_compress & 0x1;
+	    if(ms_stereo) {
+          tab1 = pow1_2[p]; tab2 = pow2_2[p];
+        }
+        else {
+          tab1 = pow1_1[p]; tab2 = pow2_1[p];
+        }
+      }
+      else {
+        if(ms_stereo) {
+          tab1 = tan1_2; tab2 = tan2_2;
+        }
+        else {
+          tab1 = tan1_1; tab2 = tan2_1;
+        }
+      }
+
+      if (gr_info->block_type == 2)
+      {
+         int lwin,do_l = 0;
+         if( gr_info->mixed_block_flag )
+           do_l = 1;
+
+         for (lwin=0;lwin<3;lwin++) /* process each window */
+         {
+             /* get first band with zero values */
+           int is_p,sb,idx,sfb = gr_info->maxband[lwin];  /* sfb is minimal 3 for mixed mode */
+           if(sfb > 3)
+             do_l = 0;
+
+           for(;sfb<12;sfb++)
+           {
+             is_p = scalefac[sfb*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */ 
+             if(is_p != 7) {
+               real t1,t2;
+               sb = bi->shortDiff[sfb];
+               idx = bi->shortIdx[sfb] + lwin;
+               t1 = tab1[is_p]; t2 = tab2[is_p];
+               for (; sb > 0; sb--,idx+=3)
+               {
+                 real v = xr[0][idx];
+                 xr[0][idx] = v * t1;
+                 xr[1][idx] = v * t2;
+               }
+             }
+           }
+
+#if 1
+/* in the original: copy 10 to 11 , here: copy 11 to 12 
+maybe still wrong??? (copy 12 to 13?) */
+           is_p = scalefac[11*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */
+           sb = bi->shortDiff[12];
+           idx = bi->shortIdx[12] + lwin;
+#else
+           is_p = scalefac[10*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */
+           sb = bi->shortDiff[11];
+           idx = bi->shortIdx[11] + lwin;
+#endif
+           if(is_p != 7)
+           {
+             real t1,t2;
+             t1 = tab1[is_p]; t2 = tab2[is_p];
+             for ( ; sb > 0; sb--,idx+=3 )
+             {  
+               real v = xr[0][idx];
+               xr[0][idx] = v * t1;
+               xr[1][idx] = v * t2;
+             }
+           }
+         } /* end for(lwin; .. ; . ) */
+
+         if (do_l)
+         {
+/* also check l-part, if ALL bands in the three windows are 'empty'
+ * and mode = mixed_mode 
+ */
+           int sfb = gr_info->maxbandl;
+           int idx = bi->longIdx[sfb];
+
+           for ( ; sfb<8; sfb++ )
+           {
+             int sb = bi->longDiff[sfb];
+             int is_p = scalefac[sfb]; /* scale: 0-15 */
+             if(is_p != 7) {
+               real t1,t2;
+               t1 = tab1[is_p]; t2 = tab2[is_p];
+               for ( ; sb > 0; sb--,idx++)
+               {
+                 real v = xr[0][idx];
+                 xr[0][idx] = v * t1;
+                 xr[1][idx] = v * t2;
+               }
+             }
+             else 
+               idx += sb;
+           }
+         }     
+      } 
+      else /* ((gr_info->block_type != 2)) */
+      {
+        int sfb = gr_info->maxbandl;
+        int is_p,idx = bi->longIdx[sfb];
+        for ( ; sfb<21; sfb++)
+        {
+          int sb = bi->longDiff[sfb];
+          is_p = scalefac[sfb]; /* scale: 0-15 */
+          if(is_p != 7) {
+            real t1,t2;
+            t1 = tab1[is_p]; t2 = tab2[is_p];
+            for ( ; sb > 0; sb--,idx++)
+            {
+               real v = xr[0][idx];
+               xr[0][idx] = v * t1;
+               xr[1][idx] = v * t2;
+            }
+          }
+          else
+            idx += sb;
+        }
+
+        is_p = scalefac[20]; /* copy l-band 20 to l-band 21 */
+        if(is_p != 7)
+        {
+          int sb;
+          real t1 = tab1[is_p],t2 = tab2[is_p]; 
+
+          for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ )
+          {
+            real v = xr[0][idx];
+            xr[0][idx] = v * t1;
+            xr[1][idx] = v * t2;
+          }
+        }
+      } /* ... */
+}
+
+static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_info)
+{
+   int sblim;
+
+   if(gr_info->block_type == 2)
+   {
+      if(!gr_info->mixed_block_flag) 
+        return;
+      sblim = 1; 
+   }
+   else {
+     sblim = gr_info->maxb-1;
+   }
+
+   /* 31 alias-reduction operations between each pair of sub-bands */
+   /* with 8 butterflies between each pair                         */
+
+   {
+     int sb;
+     real *xr1=(real *) xr[1];
+
+     for(sb=sblim;sb;sb--,xr1+=10)
+     {
+       int ss;
+       real *cs=aa_cs,*ca=aa_ca;
+       real *xr2 = xr1;
+
+       for(ss=7;ss>=0;ss--)
+       {       /* upper and lower butterfly inputs */
+         register real bu = *--xr2,bd = *xr1;
+         *xr2   = (bu * (*cs)   ) - (bd * (*ca)   );
+         *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );
+       }
+     }
+  }
+}
+
+/*
+ DCT insipired by Jeff Tsay's DCT from the maplay package
+ this is an optimized version with manual unroll.
+
+ References:
+ [1] S. Winograd: "On Computing the Discrete Fourier Transform",
+     Mathematics of Computation, Volume 32, Number 141, January 1978,
+     Pages 175-199
+*/
+
+static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)
+{
+  {
+    register real *in = inbuf;
+
+    in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14];
+    in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11];
+    in[11]+=in[10]; in[10]+=in[9];  in[9] +=in[8];
+    in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
+    in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];
+    in[2] +=in[1];  in[1] +=in[0];
+
+    in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
+    in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
+
+
+  {
+
+#define MACRO0(v) { \
+    real tmp; \
+    out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; \
+    out2[8-(v)] = tmp * w[26-(v)];  } \
+    sum0 -= sum1; \
+    ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; \
+    ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; 
+#define MACRO1(v) { \
+	real sum0,sum1; \
+    sum0 = tmp1a + tmp2a; \
+	sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; \
+	MACRO0(v); }
+#define MACRO2(v) { \
+    real sum0,sum1; \
+    sum0 = tmp2a - tmp1a; \
+    sum1 = (tmp2b - tmp1b) * tfcos36[(v)]; \
+	MACRO0(v); }
+
+    register const real *c = COS9;
+    register real *out2 = o2;
+	register real *w = wintab;
+	register real *out1 = o1;
+	register real *ts = tsbuf;
+
+    real ta33,ta66,tb33,tb66;
+
+    ta33 = in[2*3+0] * c[3];
+    ta66 = in[2*6+0] * c[6];
+    tb33 = in[2*3+1] * c[3];
+    tb66 = in[2*6+1] * c[6];
+
+    { 
+      real tmp1a,tmp2a,tmp1b,tmp2b;
+      tmp1a =             in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7];
+      tmp1b =             in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7];
+      tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8];
+      tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8];
+
+      MACRO1(0);
+      MACRO2(8);
+    }
+
+    {
+      real tmp1a,tmp2a,tmp1b,tmp2b;
+      tmp1a = ( in[2*1+0] - in[2*5+0] - in[2*7+0] ) * c[3];
+      tmp1b = ( in[2*1+1] - in[2*5+1] - in[2*7+1] ) * c[3];
+      tmp2a = ( in[2*2+0] - in[2*4+0] - in[2*8+0] ) * c[6] - in[2*6+0] + in[2*0+0];
+      tmp2b = ( in[2*2+1] - in[2*4+1] - in[2*8+1] ) * c[6] - in[2*6+1] + in[2*0+1];
+
+      MACRO1(1);
+      MACRO2(7);
+    }
+
+    {
+      real tmp1a,tmp2a,tmp1b,tmp2b;
+      tmp1a =             in[2*1+0] * c[5] - ta33 - in[2*5+0] * c[7] + in[2*7+0] * c[1];
+      tmp1b =             in[2*1+1] * c[5] - tb33 - in[2*5+1] * c[7] + in[2*7+1] * c[1];
+      tmp2a = in[2*0+0] - in[2*2+0] * c[8] - in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4];
+      tmp2b = in[2*0+1] - in[2*2+1] * c[8] - in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4];
+
+      MACRO1(2);
+      MACRO2(6);
+    }
+
+    {
+      real tmp1a,tmp2a,tmp1b,tmp2b;
+      tmp1a =             in[2*1+0] * c[7] - ta33 + in[2*5+0] * c[1] - in[2*7+0] * c[5];
+      tmp1b =             in[2*1+1] * c[7] - tb33 + in[2*5+1] * c[1] - in[2*7+1] * c[5];
+      tmp2a = in[2*0+0] - in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66 - in[2*8+0] * c[2];
+      tmp2b = in[2*0+1] - in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66 - in[2*8+1] * c[2];
+
+      MACRO1(3);
+      MACRO2(5);
+    }
+
+	{
+		real sum0,sum1;
+    	sum0 =  in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0];
+    	sum1 = (in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ) * tfcos36[4];
+		MACRO0(4);
+	}
+  }
+
+  }
+}
+
+/*
+ * new DCT12
+ */
+static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts)
+{
+#define DCT12_PART1 \
+             in5 = in[5*3];  \
+     in5 += (in4 = in[4*3]); \
+     in4 += (in3 = in[3*3]); \
+     in3 += (in2 = in[2*3]); \
+     in2 += (in1 = in[1*3]); \
+     in1 += (in0 = in[0*3]); \
+                             \
+     in5 += in3; in3 += in1; \
+                             \
+     in2 *= COS6_1; \
+     in3 *= COS6_1; \
+
+#define DCT12_PART2 \
+     in0 += in4 * COS6_2; \
+                          \
+     in4 = in0 + in2;     \
+     in0 -= in2;          \
+                          \
+     in1 += in5 * COS6_2; \
+                          \
+     in5 = (in1 + in3) * tfcos12[0]; \
+     in1 = (in1 - in3) * tfcos12[2]; \
+                         \
+     in3 = in4 + in5;    \
+     in4 -= in5;         \
+                         \
+     in2 = in0 + in1;    \
+     in0 -= in1;
+
+
+   {
+     real in0,in1,in2,in3,in4,in5;
+     register real *out1 = rawout1;
+     ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2];
+     ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5];
+ 
+     DCT12_PART1
+
+     {
+       real tmp0,tmp1 = (in0 - in4);
+       {
+         real tmp2 = (in1 - in5) * tfcos12[1];
+         tmp0 = tmp1 + tmp2;
+         tmp1 -= tmp2;
+       }
+       ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1];
+       ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1];
+       ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1];
+       ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1];
+     }
+
+     DCT12_PART2
+
+     ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0];
+     ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0];
+     ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2];
+     ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2];
+
+     ts[(6+0)*SBLIMIT]  = out1[6+0] + in0 * wi[0];
+     ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0];
+     ts[(6+2)*SBLIMIT]  = out1[6+2] + in4 * wi[2];
+     ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2];
+  }
+
+  in++;
+
+  {
+     real in0,in1,in2,in3,in4,in5;
+     register real *out2 = rawout2;
+ 
+     DCT12_PART1
+
+     {
+       real tmp0,tmp1 = (in0 - in4);
+       {
+         real tmp2 = (in1 - in5) * tfcos12[1];
+         tmp0 = tmp1 + tmp2;
+         tmp1 -= tmp2;
+       }
+       out2[5-1] = tmp0 * wi[11-1];
+       out2[0+1] = tmp0 * wi[6+1];
+       ts[(12+1)*SBLIMIT] += tmp1 * wi[1];
+       ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1];
+     }
+
+     DCT12_PART2
+
+     out2[5-0] = in2 * wi[11-0];
+     out2[0+0] = in2 * wi[6+0];
+     out2[0+2] = in3 * wi[6+2];
+     out2[5-2] = in3 * wi[11-2];
+
+     ts[(12+0)*SBLIMIT] += in0 * wi[0];
+     ts[(17-0)*SBLIMIT] += in0 * wi[5-0];
+     ts[(12+2)*SBLIMIT] += in4 * wi[2];
+     ts[(17-2)*SBLIMIT] += in4 * wi[5-2];
+  }
+
+  in++; 
+
+  {
+     real in0,in1,in2,in3,in4,in5;
+     register real *out2 = rawout2;
+     out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0;
+
+     DCT12_PART1
+
+     {
+       real tmp0,tmp1 = (in0 - in4);
+       {
+         real tmp2 = (in1 - in5) * tfcos12[1];
+         tmp0 = tmp1 + tmp2;
+         tmp1 -= tmp2;
+       }
+       out2[11-1] = tmp0 * wi[11-1];
+       out2[6 +1] = tmp0 * wi[6+1];
+       out2[0+1] += tmp1 * wi[1];
+       out2[5-1] += tmp1 * wi[5-1];
+     }
+
+     DCT12_PART2
+
+     out2[11-0] = in2 * wi[11-0];
+     out2[6 +0] = in2 * wi[6+0];
+     out2[6 +2] = in3 * wi[6+2];
+     out2[11-2] = in3 * wi[11-2];
+
+     out2[0+0] += in0 * wi[0];
+     out2[5-0] += in0 * wi[5-0];
+     out2[0+2] += in4 * wi[2];
+     out2[5-2] += in4 * wi[5-2];
+  }
+}
+
+/*
+ * III_hybrid
+ */
+static void III_hybrid(struct mpstr *mp, real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],
+   int ch,struct gr_info_s *gr_info)
+{
+   real *tspnt = (real *) tsOut;
+   real (*block)[2][SBLIMIT*SSLIMIT] = mp->hybrid_block;
+   int *blc = mp->hybrid_blc;
+   real *rawout1,*rawout2;
+   int bt;
+   int sb = 0;
+
+   {
+     int b = blc[ch];
+     rawout1=block[b][ch];
+     b=-b+1;
+     rawout2=block[b][ch];
+     blc[ch] = b;
+   }
+
+  
+   if(gr_info->mixed_block_flag) {
+     sb = 2;
+     dct36(fsIn[0],rawout1,rawout2,win[0],tspnt);
+     dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);
+     rawout1 += 36; rawout2 += 36; tspnt += 2;
+   }
+ 
+   bt = gr_info->block_type;
+   if(bt == 2) {
+     for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
+       dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt);
+       dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1);
+     }
+   }
+   else {
+     for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
+       dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt);
+       dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);
+     }
+   }
+
+   for(;sb<SBLIMIT;sb++,tspnt++) {
+     int i;
+     for(i=0;i<SSLIMIT;i++) {
+       tspnt[i*SBLIMIT] = *rawout1++;
+       *rawout2++ = 0.0;
+     }
+   }
+}
+
+/*
+ * main layer3 handler
+ */
+int do_layer3(struct mpstr *mp,unsigned char *pcm_sample,int *pcm_point)
+{
+
+  int gr, ch, ss,clip=0;
+  int scalefacs[39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */
+  struct III_sideinfo sideinfo;
+  struct frame *fr;
+  int stereo, single, sfreq;
+  int ms_stereo,i_stereo;
+  int stereo1,granules;
+
+  fr = &(mp->fr);
+  stereo = fr->stereo;
+  single = fr->single;
+  sfreq = fr->sampling_frequency;
+
+  
+  
+  if(stereo == 1) { /* stream is mono */
+    stereo1 = 1;
+    single = 0;
+  }
+  else if(single >= 0) /* stream is stereo, but force to mono */
+    stereo1 = 1;
+  else
+    stereo1 = 2;
+
+  if(fr->mode == MPG_MD_JOINT_STEREO) {
+    ms_stereo = fr->mode_ext & 0x2;
+    i_stereo  = fr->mode_ext & 0x1;
+  }
+  else
+    ms_stereo = i_stereo = 0;
+
+  if(fr->lsf) {
+    granules = 1;
+    if (III_get_side_info_2(mp, &sideinfo,stereo,ms_stereo,sfreq,single))
+	    return (MP3_ERR);
+  }
+  else {
+    granules = 2;
+#ifdef MPEG1
+   if ( III_get_side_info_1(mp, &sideinfo,stereo,ms_stereo,sfreq,single))
+	   return (MP3_ERR);
+   
+#else
+    ast_log(LOG_WARNING,"Not supported\n");
+#endif
+  }
+
+  if(set_pointer(mp, sideinfo.main_data_begin) == MP3_ERR)
+    return 0;
+
+  for (gr=0;gr<granules;gr++) 
+  {
+    static real hybridIn[2][SBLIMIT][SSLIMIT];
+    static real hybridOut[2][SSLIMIT][SBLIMIT];
+
+    {
+      struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]);
+      long part2bits;
+      if(fr->lsf)
+        part2bits = III_get_scale_factors_2(mp, scalefacs,gr_info,0);
+      else {
+#ifdef MPEG1
+        part2bits = III_get_scale_factors_1(mp, scalefacs,gr_info);
+#else
+	ast_log(LOG_WARNING,"Not supported\n");
+#endif
+      }
+      if(III_dequantize_sample(mp, hybridIn[0], scalefacs,gr_info,sfreq,part2bits))
+        return (MP3_ERR);
+    }
+    if(stereo == 2) {
+      struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]);
+      long part2bits;
+      if(fr->lsf) 
+        part2bits = III_get_scale_factors_2(mp, scalefacs,gr_info,i_stereo);
+      else {
+#ifdef MPEG1
+        part2bits = III_get_scale_factors_1(mp, scalefacs,gr_info);
+#else
+	ast_log(LOG_WARNING,"Not supported\n");
+#endif
+      }
+
+      if(III_dequantize_sample(mp, hybridIn[1],scalefacs,gr_info,sfreq,part2bits))
+          return (MP3_ERR);
+
+      if(ms_stereo) {
+        int i;
+        for(i=0;i<SBLIMIT*SSLIMIT;i++) {
+          real tmp0,tmp1;
+          tmp0 = ((real *) hybridIn[0])[i];
+          tmp1 = ((real *) hybridIn[1])[i];
+          ((real *) hybridIn[1])[i] = tmp0 - tmp1;  
+          ((real *) hybridIn[0])[i] = tmp0 + tmp1;
+        }
+      }
+
+      if(i_stereo)
+        III_i_stereo(hybridIn,scalefacs,gr_info,sfreq,ms_stereo,fr->lsf);
+
+      if(ms_stereo || i_stereo || (single == 3) ) {
+        if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb) 
+          sideinfo.ch[0].gr[gr].maxb = gr_info->maxb;
+        else
+          gr_info->maxb = sideinfo.ch[0].gr[gr].maxb;
+      }
+
+      switch(single) {
+        case 3:
+          {
+            register int i;
+            register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
+            for(i=0;i<SSLIMIT*gr_info->maxb;i++,in0++)
+              *in0 = (*in0 + *in1++); /* *0.5 done by pow-scale */ 
+          }
+          break;
+        case 1:
+          {
+            register int i;
+            register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
+            for(i=0;i<SSLIMIT*gr_info->maxb;i++)
+              *in0++ = *in1++;
+          }
+          break;
+      }
+    }
+
+    for(ch=0;ch<stereo1;ch++) {
+      struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]);
+      III_antialias(hybridIn[ch],gr_info);
+      III_hybrid(mp, hybridIn[ch], hybridOut[ch], ch,gr_info);
+    }
+
+    for(ss=0;ss<SSLIMIT;ss++) {
+      if(single >= 0) {
+        clip += synth_ntom_mono(mp,hybridOut[0][ss],pcm_sample,pcm_point);
+      }
+      else {
+        int p1 = *pcm_point;
+        clip += synth_ntom(mp,hybridOut[0][ss],0,pcm_sample,&p1);
+        clip += synth_ntom(mp,hybridOut[1][ss],1,pcm_sample,pcm_point);
+      }
+    }
+  }
+  
+  return 0;
+}
+
+
diff --git a/addons/mp3/mpg123.h b/addons/mp3/mpg123.h
new file mode 100644
index 000000000..e607cc277
--- /dev/null
+++ b/addons/mp3/mpg123.h
@@ -0,0 +1,132 @@
+#include        <stdio.h>
+#include        <string.h>
+#include        <signal.h>
+
+#ifndef WIN32
+#include        <sys/signal.h>
+#include        <unistd.h>
+#endif
+
+#include        <math.h>
+
+#ifdef _WIN32
+# undef WIN32
+# define WIN32
+
+# define M_PI       3.14159265358979323846
+# define M_SQRT2	1.41421356237309504880
+# define REAL_IS_FLOAT
+# define NEW_DCT9
+
+# define random rand
+# define srandom srand
+
+#endif
+
+#ifdef REAL_IS_FLOAT
+#  define real float
+#elif defined(REAL_IS_LONG_DOUBLE)
+#  define real long double
+#else
+#  define real double
+#endif
+
+#ifdef __GNUC__
+#define INLINE inline
+#else
+#define INLINE
+#endif
+
+/* AUDIOBUFSIZE = n*64 with n=1,2,3 ...  */
+#define		AUDIOBUFSIZE		16384
+
+#define         FALSE                   0
+#define         TRUE                    1
+
+#define         SBLIMIT                 32
+#define         SSLIMIT                 18
+
+#define         MPG_MD_STEREO           0
+#define         MPG_MD_JOINT_STEREO     1
+#define         MPG_MD_DUAL_CHANNEL     2
+#define         MPG_MD_MONO             3
+
+#define MAXFRAMESIZE 1792
+
+
+/* Pre Shift fo 16 to 8 bit converter table */
+#define AUSHIFT (3)
+
+struct frame {
+    int stereo;
+    int jsbound;
+    int single;
+    int lsf;
+    int mpeg25;
+    int header_change;
+    int lay;
+    int error_protection;
+    int bitrate_index;
+    int sampling_frequency;
+    int padding;
+    int extension;
+    int mode;
+    int mode_ext;
+    int copyright;
+    int original;
+    int emphasis;
+    int framesize; /* computed framesize */
+};
+
+struct parameter {
+	int quiet;	/* shut up! */
+	int tryresync;  /* resync stream after error */
+	int verbose;    /* verbose level */
+	int checkrange;
+};
+
+extern int decode_header(struct frame *fr,unsigned long newhead);
+
+
+
+struct gr_info_s {
+      int scfsi;
+      unsigned part2_3_length;
+      unsigned big_values;
+      unsigned scalefac_compress;
+      unsigned block_type;
+      unsigned mixed_block_flag;
+      unsigned table_select[3];
+      unsigned subblock_gain[3];
+      unsigned maxband[3];
+      unsigned maxbandl;
+      unsigned maxb;
+      unsigned region1start;
+      unsigned region2start;
+      unsigned preflag;
+      unsigned scalefac_scale;
+      unsigned count1table_select;
+      real *full_gain[3];
+      real *pow2gain;
+};
+
+struct III_sideinfo
+{
+  unsigned main_data_begin;
+  unsigned private_bits;
+  struct {
+    struct gr_info_s gr[2];
+  } ch[2];
+};
+
+struct pcm_workingsample
+{
+	int bitindex;
+	unsigned char *wordpointer;
+};
+
+
+extern long freqs[9];
+extern struct parameter param;
+extern real *pnts[5];
+
diff --git a/addons/mp3/mpglib.h b/addons/mp3/mpglib.h
new file mode 100644
index 000000000..0613222e6
--- /dev/null
+++ b/addons/mp3/mpglib.h
@@ -0,0 +1,75 @@
+
+struct buf {
+        unsigned char *pnt;
+	long size;
+	long pos;
+        struct buf *next;
+        struct buf *prev;
+};
+
+struct framebuf {
+	struct buf *buf;
+	long pos;
+	struct frame *next;
+	struct frame *prev;
+};
+
+struct mpstr {
+	struct buf *head,*tail;
+	int bsize;
+	int framesize;
+        int fsizeold;
+	struct frame fr;
+        unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */
+	real hybrid_block[2][2][SBLIMIT*SSLIMIT];
+	int hybrid_blc[2];
+	unsigned long header;
+	int bsnum;
+	real synth_buffs[2][2][0x110];
+        int  synth_bo;
+	long outscale; /* volume control default value 32768 */
+	long outsamplerate; /* raw output rate default same as mp3 sample rate*/
+	struct pcm_workingsample worksample; /* keep the state of the working sample for threads */
+	int initmp3; /* flag for first initialisation */
+	int longLimit[9][23]; /*sample limits re setting volume */
+	int shortLimit[9][14];
+	real decwin[512+32]; /* scale table */
+	
+	};
+
+#define BOOL int
+
+#define MP3_ERR -1
+#define MP3_OK  0
+#define MP3_NEED_MORE 1
+
+
+void InitMP3Constants(void);
+BOOL InitMP3(struct mpstr *mp, long outscale);
+int decodeMP3(struct mpstr *mp,char *inmemory,int inmemsize,
+     char *outmemory,int outmemsize,int *done);
+void ExitMP3(struct mpstr *mp);
+
+extern int synth_ntom_set_step(long,long);
+extern int synth_ntom(struct mpstr *mp, real *bandPtr,int channel,unsigned char *out,int *pnt);
+extern int synth_ntom_mono (struct mpstr *mp, real *bandPtr,unsigned char *samples,int *pnt);
+extern int synth_ntom_8bit (real *,int,unsigned char *,int *);
+extern int synth_ntom_mono2stereo (real *,unsigned char *,int *);
+extern int synth_ntom_8bit_mono (real *,unsigned char *,int *);
+extern int synth_ntom_8bit_mono2stereo (real *,unsigned char *,int *);
+
+extern void init_layer3_sample_limits(struct mpstr *mp, int down_sample_sblimit);
+extern void init_layer3_const(void);
+extern int do_layer3(struct mpstr *mp,unsigned char *,int *);
+
+extern void make_decode_tables_scale(struct mpstr *mp, long scaleval);
+extern void make_decode_tables_const(void);
+extern void make_conv16to8_table(int);
+
+extern void dct64(real *,real *,real *);
+
+extern unsigned int   get1bit(struct mpstr *mp);
+extern unsigned int   getbits(struct mpstr *mp, int);
+extern unsigned int   getbits_fast(struct mpstr *mp, int);
+extern int set_pointer(struct mpstr *mp, long backstep);
+
diff --git a/addons/mp3/tabinit.c b/addons/mp3/tabinit.c
new file mode 100644
index 000000000..d3e49f500
--- /dev/null
+++ b/addons/mp3/tabinit.c
@@ -0,0 +1,81 @@
+
+#include <stdlib.h>
+
+#include "mpg123.h"
+#include "mpglib.h"
+
+static real cos64[16],cos32[8],cos16[4],cos8[2],cos4[1];
+real *pnts[] = { cos64,cos32,cos16,cos8,cos4 };
+
+static long intwinbase[] = {
+     0,    -1,    -1,    -1,    -1,    -1,    -1,    -2,    -2,    -2,
+    -2,    -3,    -3,    -4,    -4,    -5,    -5,    -6,    -7,    -7,
+    -8,    -9,   -10,   -11,   -13,   -14,   -16,   -17,   -19,   -21,
+   -24,   -26,   -29,   -31,   -35,   -38,   -41,   -45,   -49,   -53,
+   -58,   -63,   -68,   -73,   -79,   -85,   -91,   -97,  -104,  -111,
+  -117,  -125,  -132,  -139,  -147,  -154,  -161,  -169,  -176,  -183,
+  -190,  -196,  -202,  -208,  -213,  -218,  -222,  -225,  -227,  -228,
+  -228,  -227,  -224,  -221,  -215,  -208,  -200,  -189,  -177,  -163,
+  -146,  -127,  -106,   -83,   -57,   -29,     2,    36,    72,   111,
+   153,   197,   244,   294,   347,   401,   459,   519,   581,   645,
+   711,   779,   848,   919,   991,  1064,  1137,  1210,  1283,  1356,
+  1428,  1498,  1567,  1634,  1698,  1759,  1817,  1870,  1919,  1962,
+  2001,  2032,  2057,  2075,  2085,  2087,  2080,  2063,  2037,  2000,
+  1952,  1893,  1822,  1739,  1644,  1535,  1414,  1280,  1131,   970,
+   794,   605,   402,   185,   -45,  -288,  -545,  -814, -1095, -1388,
+ -1692, -2006, -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788,
+ -5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597, -7910, -8209,
+ -8491, -8755, -8998, -9219, -9416, -9585, -9727, -9838, -9916, -9959,
+ -9966, -9935, -9863, -9750, -9592, -9389, -9139, -8840, -8492, -8092,
+ -7640, -7134, -6574, -5959, -5288, -4561, -3776, -2935, -2037, -1082,
+   -70,   998,  2122,  3300,  4533,  5818,  7154,  8540,  9975, 11455,
+ 12980, 14548, 16155, 17799, 19478, 21189, 22929, 24694, 26482, 28289,
+ 30112, 31947, 33791, 35640, 37489, 39336, 41176, 43006, 44821, 46617,
+ 48390, 50137, 51853, 53534, 55178, 56778, 58333, 59838, 61289, 62684,
+ 64019, 65290, 66494, 67629, 68692, 69679, 70590, 71420, 72169, 72835,
+ 73415, 73908, 74313, 74630, 74856, 74992, 75038 };
+
+void make_decode_tables_const(void)
+{
+	int i,k,kr,divv;
+	real *costab;
+		
+	for(i=0;i<5;i++)
+	{
+		kr=0x10>>i; divv=0x40>>i;
+		costab = pnts[i];
+		for(k=0;k<kr;k++)
+			costab[k] = 1.0 / (2.0 * cos(M_PI * ((double) k * 2.0 + 1.0) / (double) divv));
+	}
+
+}
+
+void make_decode_tables_scale(struct mpstr *mp, long scaleval)
+{
+  int i,j;
+  real *table;
+  
+  table = mp->decwin;
+  scaleval = -scaleval;
+  for(i=0,j=0;i<256;i++,j++,table+=32)
+  {
+    if(table < (mp->decwin)+512+16)
+      table[16] = table[0] = (double) intwinbase[j] / 65536.0 * (double) scaleval;
+    if(i % 32 == 31)
+      table -= 1023;
+    if(i % 64 == 63)
+      scaleval = - scaleval;
+  }
+
+  for( /* i=256 */ ;i<512;i++,j--,table+=32)
+  {
+    if(table < (mp->decwin)+512+16)
+      table[16] = table[0] = (double) intwinbase[j] / 65536.0 * (double) scaleval;
+    if(i % 32 == 31)
+      table -= 1023;
+    if(i % 64 == 63)
+      scaleval = - scaleval;
+  }
+}
+
+
diff --git a/addons/ooh323c/COPYING b/addons/ooh323c/COPYING
new file mode 100644
index 000000000..b8306825e
--- /dev/null
+++ b/addons/ooh323c/COPYING
@@ -0,0 +1,341 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
+
diff --git a/addons/ooh323c/README b/addons/ooh323c/README
new file mode 100644
index 000000000..e1a5b20e4
--- /dev/null
+++ b/addons/ooh323c/README
@@ -0,0 +1,95 @@
+Copyright (C) 2004-2005 by Objective Systems, Inc.
+
+Objective Open H.323 README
+
+Introduction
+Objective Open H.323 stack is a simple H.323 implementation in C. This
+package contains the core stack code. For complete H.323 stack package with
+examples or for more information visit www.obj-sys.com/open
+ The ASN.1 messaging code was developed using the Objective Systems ASN1C 
+compiler to implement the core H.323 specifications (H.225, H.235, 
+and H.245).  Additional code was then developed which makes use of 
+the compiler generated code for presenting a comparatively high level 
+stack API.
+
+Features
+
+Features supported in this package include the following:
+
+* H.225/Q.931 - the following message types are supported (including 
+  support for FastStart and H.245 tunneling): 
+  - Setup 
+  - Connect
+  - Call Proceeding
+  - Alerting 
+  - Facility
+  - ReleaseComplete
+
+* H.225/RAS - the following message types are supported
+  - GateKeeperRequest / Response
+  - RegistrationRequest / Response
+  - AdmissionRequest / Response
+  - DisengageRequest / Response
+
+* H.245 - the following message types are supported
+  - MasterSlaveDetermination
+  - MasterSlaveDeterminationAck
+  - MasterSlaveDeterminationReject
+  - MasterSlaveDeterminationRelease
+  - TerminalCapabilitySet
+  - TerminalCapabilitySetReject
+  - TerminalCapabilitySetRelease
+  - TerminalCapabilitySetAck
+  - OpenLogicalChannel
+  - OpenLogicalChannelAck
+  - OpenLogicalChannelReject
+  - CloseLogicalChannel
+  - CloseLogicalChannelAck
+  - RequestChannelClose
+  - RequestChannelCloseAck
+  - RequestChannelCloseReject
+  - RequestChannelCloseRelease
+
+
+To run the stack test application chansetup
+   chansetup - This is a sample program developed for testing multiple calls.
+   This program allows stack testing by placing multiple calls. The number of
+   calls, duration of each call and interval between successive calls are 
+   configurable.  
+
+1. Two instances of this program have to be run. Can be run on same machine or
+   different machines.
+
+2. First change to chansetup directory.
+
+        cd tests/chansetup
+
+2. For running listener instance, 
+
+        ./h323peer [--use-ip ip] [--use-port port]
+
+   where local ip address and port can be specified for listening to incoming 
+   calls. By default, application determines ip address and uses default H323
+   port number 1720.
+
+3. For running calling instance
+ 
+        ./h323peer [--use-ip ip] -n <number of calls> -duration <call duration>
+                   -interval <inetrval between successive calls> destination
+      
+   where all times are in seconds. Interval of 0 means next call will be placed
+   after current call finishes. "destination" is the dotted ip address of the
+   endpoint running listener instance.
+
+   NOTE: More sample programs are available in the original ooh323c package
+   which can be downloaded from www.obj-sys.com/open
+
+Reporting Problems:
+
+Report problems you encounter by sending E-mail to support@obj-sys.com. 
+
+If you have any further questions or comments on what you would like to
+see in the product or what is difficult to use or understand, please 
+communicate them to us. Your feedback is important to us. Please let us
+know how it works out for you - either good or bad. 
+
diff --git a/addons/ooh323c/src/Makefile.in b/addons/ooh323c/src/Makefile.in
new file mode 100644
index 000000000..d3a96024b
--- /dev/null
+++ b/addons/ooh323c/src/Makefile.in
@@ -0,0 +1,564 @@
+# Makefile.in generated by automake 1.6.3 from Makefile.am.
+# @configure_input@
+
+# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
+# Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+SHELL = @SHELL@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+bindir = @bindir@
+sbindir = @sbindir@
+libexecdir = @libexecdir@
+datadir = @datadir@
+sysconfdir = @sysconfdir@
+sharedstatedir = @sharedstatedir@
+localstatedir = @localstatedir@
+libdir = @libdir@
+infodir = @infodir@
+mandir = @mandir@
+includedir = @includedir@
+oldincludedir = /usr/include
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ../..
+
+ACLOCAL = @ACLOCAL@
+AUTOCONF = @AUTOCONF@
+AUTOMAKE = @AUTOMAKE@
+AUTOHEADER = @AUTOHEADER@
+
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_DATA = @INSTALL_DATA@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = @program_transform_name@
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_alias = @host_alias@
+host_triplet = @host@
+
+EXEEXT = @EXEEXT@
+OBJEXT = @OBJEXT@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+AMTAR = @AMTAR@
+AS = @AS@
+AWK = @AWK@
+CC = @CC@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+ECHO = @ECHO@
+INSTALLPREFIX = @INSTALLPREFIX@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+OBJDUMP = @OBJDUMP@
+OOH323CDRIVERDIR = @OOH323CDRIVERDIR@
+OOH323CFLAGS = @OOH323CFLAGS@
+PACKAGE = @PACKAGE@
+RANLIB = @RANLIB@
+STRIP = @STRIP@
+VERSION = @VERSION@
+am__include = @am__include@
+am__quote = @am__quote@
+install_sh = @install_sh@
+AUTOMAKE_OPTIONS = gnu
+CFLAGS = @OOH323CFLAGS@
+
+noinst_LIBRARIES = libooh323c.a
+
+libooh323c_a_SOURCES = ooLogChan.h ooLogChan.c ooUtils.c ooUtils.h ooGkClient.h ooGkClient.c context.c ooCommon.h ooDateTime.h ooDateTime.c decode.c dlist.c encode.c errmgmt.c memheap.c memheap.h ooasn1.h  ootrace.h ootrace.c oochannels.c oochannels.h ooh245.c ooh245.h oohdr.h ooper.h ooports.c ooports.h ooq931.c ooq931.h ooCapability.c ooCapability.h ooSocket.c ooSocket.h ootypes.h perutil.c eventHandler.c eventHandler.h ooCalls.c ooCalls.h ooStackCmds.c ooStackCmds.h ooh323.c ooh323.h ooh323ep.c ooh323ep.h printHandler.c printHandler.h rtctype.c rtctype.h ooTimer.c ooTimer.h h323/H235-SECURITY-MESSAGESDec.c h323/H235-SECURITY-MESSAGESEnc.c h323/H235-SECURITY-MESSAGES.h h323/H323-MESSAGES.c h323/H323-MESSAGESDec.c h323/H323-MESSAGESEnc.c h323/H323-MESSAGES.h h323/MULTIMEDIA-SYSTEM-CONTROL.c h323/MULTIMEDIA-SYSTEM-CONTROLDec.c h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c h323/MULTIMEDIA-SYSTEM-CONTROL.h
+
+INCLUDES = -Ih323
+
+
+#include_HEADERS = ooUtils.h memheap.h ooCommon.h ooDateTime.h ooGkClient.h ooasn1.h oochannels.h ootrace.h ooh245.h ooports.h ooq931.h oohdr.h ooper.h ooSocket.h ooTimer.h ootypes.h eventHandler.h ooCapability.h ooCalls.h ooStackCmds.h ooh323.h ooh323ep.h printHandler.h rtctype.h h323/H235-SECURITY-MESSAGES.h h323/H323-MESSAGES.h h323/MULTIMEDIA-SYSTEM-CONTROL.h 
+EXTRA_DIST = oostk.dsp
+subdir = ooh323c/src
+mkinstalldirs = $(SHELL) $(top_srcdir)/config/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+LIBRARIES = $(noinst_LIBRARIES)
+
+libooh323c_a_AR = $(AR) cru
+libooh323c_a_LIBADD =
+am_libooh323c_a_OBJECTS = ooLogChan.$(OBJEXT) ooUtils.$(OBJEXT) \
+	ooGkClient.$(OBJEXT) context.$(OBJEXT) ooDateTime.$(OBJEXT) \
+	decode.$(OBJEXT) dlist.$(OBJEXT) encode.$(OBJEXT) \
+	errmgmt.$(OBJEXT) memheap.$(OBJEXT) ootrace.$(OBJEXT) \
+	oochannels.$(OBJEXT) ooh245.$(OBJEXT) ooports.$(OBJEXT) \
+	ooq931.$(OBJEXT) ooCapability.$(OBJEXT) ooSocket.$(OBJEXT) \
+	perutil.$(OBJEXT) eventHandler.$(OBJEXT) ooCalls.$(OBJEXT) \
+	ooStackCmds.$(OBJEXT) ooh323.$(OBJEXT) ooh323ep.$(OBJEXT) \
+	printHandler.$(OBJEXT) rtctype.$(OBJEXT) ooTimer.$(OBJEXT) \
+	H235-SECURITY-MESSAGESDec.$(OBJEXT) \
+	H235-SECURITY-MESSAGESEnc.$(OBJEXT) H323-MESSAGES.$(OBJEXT) \
+	H323-MESSAGESDec.$(OBJEXT) H323-MESSAGESEnc.$(OBJEXT) \
+	MULTIMEDIA-SYSTEM-CONTROL.$(OBJEXT) \
+	MULTIMEDIA-SYSTEM-CONTROLDec.$(OBJEXT) \
+	MULTIMEDIA-SYSTEM-CONTROLEnc.$(OBJEXT)
+libooh323c_a_OBJECTS = $(am_libooh323c_a_OBJECTS)
+
+DEFS = @DEFS@
+DEFAULT_INCLUDES =  -I. -I$(srcdir) -I$(top_builddir)
+CPPFLAGS = @CPPFLAGS@
+LDFLAGS = @LDFLAGS@
+LIBS = @LIBS@
+depcomp = $(SHELL) $(top_srcdir)/config/depcomp
+am__depfiles_maybe = depfiles
+@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/H235-SECURITY-MESSAGESDec.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/H323-MESSAGES.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/H323-MESSAGESDec.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/H323-MESSAGESEnc.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/context.Po ./$(DEPDIR)/decode.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/dlist.Po ./$(DEPDIR)/encode.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/errmgmt.Po ./$(DEPDIR)/eventHandler.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/memheap.Po ./$(DEPDIR)/ooCalls.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/ooCapability.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/ooDateTime.Po ./$(DEPDIR)/ooGkClient.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/ooLogChan.Po ./$(DEPDIR)/ooSocket.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/ooStackCmds.Po ./$(DEPDIR)/ooTimer.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/ooUtils.Po ./$(DEPDIR)/oochannels.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/ooh245.Po ./$(DEPDIR)/ooh323.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/ooh323ep.Po ./$(DEPDIR)/ooports.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/ooq931.Po ./$(DEPDIR)/ootrace.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/perutil.Po ./$(DEPDIR)/printHandler.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/rtctype.Po
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) \
+	$(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+DIST_SOURCES = $(libooh323c_a_SOURCES)
+DIST_COMMON = Makefile.am Makefile.in
+SOURCES = $(libooh323c_a_SOURCES)
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in:  Makefile.am  $(top_srcdir)/configure.in $(ACLOCAL_M4)
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu  ooh323c/src/Makefile
+Makefile:  $(srcdir)/Makefile.in  $(top_builddir)/config.status
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)
+
+AR = ar
+
+clean-noinstLIBRARIES:
+	-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
+H235-SECURITY-MESSAGESDec.$(OBJEXT): h323/H235-SECURITY-MESSAGESDec.c
+H235-SECURITY-MESSAGESEnc.$(OBJEXT): h323/H235-SECURITY-MESSAGESEnc.c
+H323-MESSAGES.$(OBJEXT): h323/H323-MESSAGES.c
+H323-MESSAGESDec.$(OBJEXT): h323/H323-MESSAGESDec.c
+H323-MESSAGESEnc.$(OBJEXT): h323/H323-MESSAGESEnc.c
+MULTIMEDIA-SYSTEM-CONTROL.$(OBJEXT): h323/MULTIMEDIA-SYSTEM-CONTROL.c
+MULTIMEDIA-SYSTEM-CONTROLDec.$(OBJEXT): \
+	h323/MULTIMEDIA-SYSTEM-CONTROLDec.c
+MULTIMEDIA-SYSTEM-CONTROLEnc.$(OBJEXT): \
+	h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c
+libooh323c.a: $(libooh323c_a_OBJECTS) $(libooh323c_a_DEPENDENCIES) 
+	-rm -f libooh323c.a
+	$(libooh323c_a_AR) libooh323c.a $(libooh323c_a_OBJECTS) $(libooh323c_a_LIBADD)
+	$(RANLIB) libooh323c.a
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT) core *.core
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H235-SECURITY-MESSAGESDec.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H323-MESSAGES.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H323-MESSAGESDec.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H323-MESSAGESEnc.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/context.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dlist.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/errmgmt.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eventHandler.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memheap.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooCalls.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooCapability.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooDateTime.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooGkClient.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooLogChan.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooSocket.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooStackCmds.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooTimer.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooUtils.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oochannels.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooh245.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooh323.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooh323ep.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooports.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooq931.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ootrace.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/perutil.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/printHandler.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rtctype.Po@am__quote@
+
+distclean-depend:
+	-rm -rf ./$(DEPDIR)
+
+.c.o:
+@AMDEP_TRUE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(COMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$<
+
+.c.obj:
+@AMDEP_TRUE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(COMPILE) -c `cygpath -w $<`
+
+.c.lo:
+@AMDEP_TRUE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LTCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<
+
+H235-SECURITY-MESSAGESDec.o: h323/H235-SECURITY-MESSAGESDec.c
+@AMDEP_TRUE@	source='h323/H235-SECURITY-MESSAGESDec.c' object='H235-SECURITY-MESSAGESDec.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.Po' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESDec.o `test -f 'h323/H235-SECURITY-MESSAGESDec.c' || echo '$(srcdir)/'`h323/H235-SECURITY-MESSAGESDec.c
+
+H235-SECURITY-MESSAGESDec.obj: h323/H235-SECURITY-MESSAGESDec.c
+@AMDEP_TRUE@	source='h323/H235-SECURITY-MESSAGESDec.c' object='H235-SECURITY-MESSAGESDec.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.Po' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESDec.obj `cygpath -w h323/H235-SECURITY-MESSAGESDec.c`
+
+H235-SECURITY-MESSAGESDec.lo: h323/H235-SECURITY-MESSAGESDec.c
+@AMDEP_TRUE@	source='h323/H235-SECURITY-MESSAGESDec.c' object='H235-SECURITY-MESSAGESDec.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.Plo' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESDec.lo `test -f 'h323/H235-SECURITY-MESSAGESDec.c' || echo '$(srcdir)/'`h323/H235-SECURITY-MESSAGESDec.c
+
+H235-SECURITY-MESSAGESEnc.o: h323/H235-SECURITY-MESSAGESEnc.c
+@AMDEP_TRUE@	source='h323/H235-SECURITY-MESSAGESEnc.c' object='H235-SECURITY-MESSAGESEnc.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Po' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESEnc.o `test -f 'h323/H235-SECURITY-MESSAGESEnc.c' || echo '$(srcdir)/'`h323/H235-SECURITY-MESSAGESEnc.c
+
+H235-SECURITY-MESSAGESEnc.obj: h323/H235-SECURITY-MESSAGESEnc.c
+@AMDEP_TRUE@	source='h323/H235-SECURITY-MESSAGESEnc.c' object='H235-SECURITY-MESSAGESEnc.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Po' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESEnc.obj `cygpath -w h323/H235-SECURITY-MESSAGESEnc.c`
+
+H235-SECURITY-MESSAGESEnc.lo: h323/H235-SECURITY-MESSAGESEnc.c
+@AMDEP_TRUE@	source='h323/H235-SECURITY-MESSAGESEnc.c' object='H235-SECURITY-MESSAGESEnc.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Plo' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESEnc.lo `test -f 'h323/H235-SECURITY-MESSAGESEnc.c' || echo '$(srcdir)/'`h323/H235-SECURITY-MESSAGESEnc.c
+
+H323-MESSAGES.o: h323/H323-MESSAGES.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGES.c' object='H323-MESSAGES.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGES.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGES.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGES.o `test -f 'h323/H323-MESSAGES.c' || echo '$(srcdir)/'`h323/H323-MESSAGES.c
+
+H323-MESSAGES.obj: h323/H323-MESSAGES.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGES.c' object='H323-MESSAGES.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGES.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGES.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGES.obj `cygpath -w h323/H323-MESSAGES.c`
+
+H323-MESSAGES.lo: h323/H323-MESSAGES.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGES.c' object='H323-MESSAGES.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGES.Plo' tmpdepfile='$(DEPDIR)/H323-MESSAGES.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGES.lo `test -f 'h323/H323-MESSAGES.c' || echo '$(srcdir)/'`h323/H323-MESSAGES.c
+
+H323-MESSAGESDec.o: h323/H323-MESSAGESDec.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGESDec.c' object='H323-MESSAGESDec.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGESDec.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGESDec.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESDec.o `test -f 'h323/H323-MESSAGESDec.c' || echo '$(srcdir)/'`h323/H323-MESSAGESDec.c
+
+H323-MESSAGESDec.obj: h323/H323-MESSAGESDec.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGESDec.c' object='H323-MESSAGESDec.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGESDec.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGESDec.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESDec.obj `cygpath -w h323/H323-MESSAGESDec.c`
+
+H323-MESSAGESDec.lo: h323/H323-MESSAGESDec.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGESDec.c' object='H323-MESSAGESDec.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGESDec.Plo' tmpdepfile='$(DEPDIR)/H323-MESSAGESDec.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESDec.lo `test -f 'h323/H323-MESSAGESDec.c' || echo '$(srcdir)/'`h323/H323-MESSAGESDec.c
+
+H323-MESSAGESEnc.o: h323/H323-MESSAGESEnc.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGESEnc.c' object='H323-MESSAGESEnc.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGESEnc.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGESEnc.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESEnc.o `test -f 'h323/H323-MESSAGESEnc.c' || echo '$(srcdir)/'`h323/H323-MESSAGESEnc.c
+
+H323-MESSAGESEnc.obj: h323/H323-MESSAGESEnc.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGESEnc.c' object='H323-MESSAGESEnc.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGESEnc.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGESEnc.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESEnc.obj `cygpath -w h323/H323-MESSAGESEnc.c`
+
+H323-MESSAGESEnc.lo: h323/H323-MESSAGESEnc.c
+@AMDEP_TRUE@	source='h323/H323-MESSAGESEnc.c' object='H323-MESSAGESEnc.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/H323-MESSAGESEnc.Plo' tmpdepfile='$(DEPDIR)/H323-MESSAGESEnc.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESEnc.lo `test -f 'h323/H323-MESSAGESEnc.c' || echo '$(srcdir)/'`h323/H323-MESSAGESEnc.c
+
+MULTIMEDIA-SYSTEM-CONTROL.o: h323/MULTIMEDIA-SYSTEM-CONTROL.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROL.c' object='MULTIMEDIA-SYSTEM-CONTROL.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROL.o `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROL.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROL.c
+
+MULTIMEDIA-SYSTEM-CONTROL.obj: h323/MULTIMEDIA-SYSTEM-CONTROL.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROL.c' object='MULTIMEDIA-SYSTEM-CONTROL.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROL.obj `cygpath -w h323/MULTIMEDIA-SYSTEM-CONTROL.c`
+
+MULTIMEDIA-SYSTEM-CONTROL.lo: h323/MULTIMEDIA-SYSTEM-CONTROL.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROL.c' object='MULTIMEDIA-SYSTEM-CONTROL.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Plo' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROL.lo `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROL.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROL.c
+
+MULTIMEDIA-SYSTEM-CONTROLDec.o: h323/MULTIMEDIA-SYSTEM-CONTROLDec.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' object='MULTIMEDIA-SYSTEM-CONTROLDec.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLDec.o `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROLDec.c
+
+MULTIMEDIA-SYSTEM-CONTROLDec.obj: h323/MULTIMEDIA-SYSTEM-CONTROLDec.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' object='MULTIMEDIA-SYSTEM-CONTROLDec.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLDec.obj `cygpath -w h323/MULTIMEDIA-SYSTEM-CONTROLDec.c`
+
+MULTIMEDIA-SYSTEM-CONTROLDec.lo: h323/MULTIMEDIA-SYSTEM-CONTROLDec.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' object='MULTIMEDIA-SYSTEM-CONTROLDec.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Plo' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLDec.lo `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROLDec.c
+
+MULTIMEDIA-SYSTEM-CONTROLEnc.o: h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' object='MULTIMEDIA-SYSTEM-CONTROLEnc.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLEnc.o `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c
+
+MULTIMEDIA-SYSTEM-CONTROLEnc.obj: h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' object='MULTIMEDIA-SYSTEM-CONTROLEnc.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLEnc.obj `cygpath -w h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c`
+
+MULTIMEDIA-SYSTEM-CONTROLEnc.lo: h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c
+@AMDEP_TRUE@	source='h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' object='MULTIMEDIA-SYSTEM-CONTROLEnc.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@	depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Plo' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLEnc.lo `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c
+CCDEPMODE = @CCDEPMODE@
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+
+ETAGS = etags
+ETAGSFLAGS =
+
+tags: TAGS
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(ETAGS_ARGS)$$tags$$unique" \
+	  || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+
+top_distdir = ../..
+distdir = $(top_distdir)/$(PACKAGE)-$(VERSION)
+
+distdir: $(DISTFILES)
+	@list='$(DISTFILES)'; for file in $$list; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkinstalldirs) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LIBRARIES)
+
+installdirs:
+
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-rm -f Makefile $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstLIBRARIES \
+	mostlyclean-am
+
+distclean: distclean-am
+
+distclean-am: clean-am distclean-compile distclean-depend \
+	distclean-generic distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+uninstall-am: uninstall-info-am
+
+.PHONY: GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-noinstLIBRARIES distclean distclean-compile \
+	distclean-depend distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am info info-am install \
+	install-am install-data install-data-am install-exec \
+	install-exec-am install-info install-info-am install-man \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+	tags uninstall uninstall-am uninstall-info-am
+
+
+opt:
+	$(MAKE) "CFLAGS = -DGNU -D_GNU_SOURCE -D_REENTRANT -O2 -D_COMPACT" all
+
+debug:
+	$(MAKE) "CFLAGS = -g -DGNU -D_GNU_SOURCE -D_REENTRANT"  all
+
+profile:
+	$(MAKE) "CFLAGS = -g -pg -DGNU -D_GNU_SOURCE -D_REENTRANT" all
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/addons/ooh323c/src/context.c b/addons/ooh323c/src/context.c
new file mode 100644
index 000000000..d243f88a0
--- /dev/null
+++ b/addons/ooh323c/src/context.c
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooasn1.h"
+#include <stdlib.h>
+
+int initContext (OOCTXT* pctxt)
+{
+   memset (pctxt, 0, sizeof(OOCTXT));
+
+   memHeapCreate (&pctxt->pTypeMemHeap);
+   pctxt->pMsgMemHeap = pctxt->pTypeMemHeap;
+   memHeapAddRef (&pctxt->pMsgMemHeap);
+
+   return ASN_OK;
+}
+
+int initContextBuffer 
+(OOCTXT* pctxt, const ASN1OCTET* bufaddr, ASN1UINT bufsiz)
+{
+   if (bufaddr == 0) {
+      /* dynamic buffer */
+      if (bufsiz == 0) bufsiz = ASN_K_ENCBUFSIZ;
+      pctxt->buffer.data = (ASN1OCTET*) 
+         memHeapAlloc (&pctxt->pMsgMemHeap, bufsiz);
+      if (!pctxt->buffer.data) return ASN_E_NOMEM;
+      pctxt->buffer.size = bufsiz;
+      pctxt->buffer.dynamic = TRUE;
+   }
+   else {
+      /* static buffer */
+      pctxt->buffer.data = (ASN1OCTET*) bufaddr;
+      pctxt->buffer.size = bufsiz;
+      pctxt->buffer.dynamic = FALSE;
+   }
+
+   pctxt->buffer.byteIndex = 0;
+   pctxt->buffer.bitOffset = 8;
+
+   return ASN_OK;
+}
+
+int initSubContext (OOCTXT* pctxt, OOCTXT* psrc) 
+{
+   int stat = ASN_OK;
+   memset (pctxt, 0, sizeof(OOCTXT));
+   pctxt->pTypeMemHeap = psrc->pTypeMemHeap;
+   memHeapAddRef (&pctxt->pTypeMemHeap);
+   pctxt->pMsgMemHeap = psrc->pMsgMemHeap;
+   memHeapAddRef (&pctxt->pMsgMemHeap);
+   pctxt->flags = psrc->flags;
+   pctxt->buffer.dynamic = TRUE;
+   pctxt->buffer.byteIndex = 0;
+   pctxt->buffer.bitOffset = 8;
+   return stat;
+}
+
+void freeContext (OOCTXT* pctxt)
+{
+   ASN1BOOL saveBuf = (pctxt->flags & ASN1SAVEBUF) != 0;
+   
+   if (pctxt->buffer.dynamic && pctxt->buffer.data) {
+      if (saveBuf) {
+         memHeapMarkSaved (&pctxt->pMsgMemHeap, pctxt->buffer.data, TRUE);
+      }
+      else {
+         memHeapFreePtr (&pctxt->pMsgMemHeap, pctxt->buffer.data);
+      }
+   }
+
+   errFreeParms (&pctxt->errInfo);
+
+   memHeapRelease (&pctxt->pTypeMemHeap);
+   memHeapRelease (&pctxt->pMsgMemHeap);
+}
+
+void copyContext (OOCTXT* pdest, OOCTXT* psrc)
+{
+   memcpy (&pdest->buffer, &psrc->buffer, sizeof(ASN1BUFFER));
+   pdest->flags = psrc->flags;
+}
+
+void setCtxtFlag (OOCTXT* pctxt, ASN1USINT mask)
+{
+   pctxt->flags |= mask;
+}
+
+void clearCtxtFlag (OOCTXT* pctxt, ASN1USINT mask)
+{
+   pctxt->flags &= ~mask;
+}
+
+int setPERBufferUsingCtxt (OOCTXT* pTarget, OOCTXT* pSource)
+{
+   int stat = initContextBuffer 
+      (pTarget, pSource->buffer.data, pSource->buffer.size);
+
+   if (ASN_OK == stat) {
+      pTarget->buffer.byteIndex = pSource->buffer.byteIndex;
+      pTarget->buffer.bitOffset = pSource->buffer.bitOffset;
+   }
+
+   return stat;
+}
+
+int setPERBuffer (OOCTXT* pctxt,
+                  ASN1OCTET* bufaddr, ASN1UINT bufsiz, ASN1BOOL aligned)
+{
+   int stat = initContextBuffer (pctxt, bufaddr, bufsiz);
+   if(stat != ASN_OK) return stat;
+
+   
+   return ASN_OK;
+}
+
+OOCTXT* newContext () 
+{
+   OOCTXT* pctxt = (OOCTXT*) ASN1CRTMALLOC0 (sizeof(OOCTXT));
+   if (pctxt) {
+      if (initContext(pctxt) != ASN_OK) {
+         ASN1CRTFREE0 (pctxt);
+         pctxt = 0;
+      }
+      pctxt->flags |= ASN1DYNCTXT;
+   }
+   return (pctxt);
+}
diff --git a/addons/ooh323c/src/decode.c b/addons/ooh323c/src/decode.c
new file mode 100644
index 000000000..d09247c94
--- /dev/null
+++ b/addons/ooh323c/src/decode.c
@@ -0,0 +1,1050 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooasn1.h"
+
+static int decode16BitConstrainedString 
+(OOCTXT* pctxt, Asn116BitCharString* pString, Asn116BitCharSet* pCharSet);
+
+static int decodeOctets 
+(OOCTXT* pctxt, ASN1OCTET* pbuffer, ASN1UINT bufsiz, ASN1UINT nbits);
+
+static int getComponentLength (OOCTXT* pctxt, ASN1UINT itemBits);
+
+int decodeBits (OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT nbits)
+{ 
+   unsigned char mask;
+
+   if (nbits == 0) {
+      *pvalue = 0;
+      return ASN_OK;
+   }
+
+   /* If the number of bits is less than the current bit offset, mask   */
+   /* off the required number of bits and return..                      */
+
+   if (nbits < (unsigned)pctxt->buffer.bitOffset) {
+      /* Check if buffer contains number of bits requested */
+
+      if (pctxt->buffer.byteIndex >= pctxt->buffer.size)
+         return LOG_ASN1ERR (pctxt, ASN_E_ENDOFBUF);
+
+      pctxt->buffer.bitOffset -= nbits;
+
+      *pvalue = ((pctxt->buffer.data[pctxt->buffer.byteIndex]) >> 
+                 pctxt->buffer.bitOffset) & ((1 << nbits) - 1);
+
+      return ASN_OK;
+   }
+
+   /* Otherwise, we first need to mask off the remaining bits in the    */
+   /* current byte, followed by a loop to extract bits from full bytes, */
+   /* followed by logic to mask of remaining bits from the start of     */
+   /* of the last byte..                                                */
+
+   else {
+      /* Check if buffer contains number of bits requested */
+
+      int nbytes = (((nbits - pctxt->buffer.bitOffset) + 7) / 8);
+      
+      if ((pctxt->buffer.byteIndex + nbytes) >= pctxt->buffer.size) {
+         return LOG_ASN1ERR (pctxt, ASN_E_ENDOFBUF);
+      }
+
+      /* first read current byte remaining bits */
+      mask = ((1 << pctxt->buffer.bitOffset) - 1);
+
+      *pvalue = (pctxt->buffer.data[pctxt->buffer.byteIndex]) & mask;
+
+      nbits -= pctxt->buffer.bitOffset;
+      pctxt->buffer.bitOffset = 8;
+      pctxt->buffer.byteIndex++;
+
+      /* second read bytes from next byteIndex */
+      while (nbits >= 8) {
+         *pvalue = (*pvalue << 8) | 
+            (pctxt->buffer.data[pctxt->buffer.byteIndex]);
+         pctxt->buffer.byteIndex++;
+         nbits -= 8;
+      }
+
+      /* third read bits & set bitoffset of the byteIndex */
+      if (nbits > 0) {
+         pctxt->buffer.bitOffset = 8 - nbits;
+         *pvalue = (*pvalue << nbits) | 
+            ((pctxt->buffer.data[pctxt->buffer.byteIndex]) >> 
+             pctxt->buffer.bitOffset);
+      }
+
+      return ASN_OK;
+   }
+}
+
+int decodeBitString 
+(OOCTXT* pctxt, ASN1UINT* numbits_p, ASN1OCTET* buffer, ASN1UINT bufsiz)
+{
+   ASN1UINT bitcnt;
+   int lstat, octidx = 0, stat;
+   Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint;
+   ASN1BOOL doAlign;
+
+   for (*numbits_p = 0;;) {
+      lstat = decodeLength (pctxt, &bitcnt);
+      if (lstat < 0) return LOG_ASN1ERR (pctxt, lstat);
+
+      if (bitcnt > 0) {
+         *numbits_p += bitcnt;
+
+         stat = bitAndOctetStringAlignmentTest 
+            (pSizeList, bitcnt, TRUE, &doAlign);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         if (doAlign) {
+            stat = decodeByteAlign (pctxt);
+            if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+         }
+
+         stat = decodeOctets (pctxt, &buffer[octidx], bufsiz - octidx, bitcnt);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+      }
+
+      if (lstat == ASN_OK_FRAG) {
+         octidx += (bitcnt / 8);
+      }
+      else break;
+   }
+
+   return ASN_OK;
+}
+
+int decodeBMPString 
+(OOCTXT* pctxt, ASN1BMPString* pvalue, Asn116BitCharSet* permCharSet)
+{
+   Asn116BitCharSet charSet;
+   int stat;
+
+   /* Set character set */
+
+   init16BitCharSet (&charSet, BMP_FIRST, BMP_LAST, BMP_ABITS, BMP_UBITS);
+
+   if (permCharSet) {
+      set16BitCharSet (pctxt, &charSet, permCharSet);
+   }
+
+   /* Decode constrained string */
+
+   stat = decode16BitConstrainedString (pctxt, pvalue, &charSet);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   return (stat);
+}
+
+int decodeByteAlign (OOCTXT* pctxt)
+{
+   if (pctxt->buffer.bitOffset != 8) {
+      pctxt->buffer.byteIndex++;
+      pctxt->buffer.bitOffset = 8;
+   }
+   return ASN_OK;
+}
+
+int decodeConstrainedStringEx 
+(OOCTXT* pctxt, const char** string, const char* charSet,
+ ASN1UINT abits, ASN1UINT ubits, ASN1UINT canSetBits)
+{
+   int   stat;
+   char* tmpstr;
+
+   ASN1UINT i, idx, len, nbits = abits;
+
+   /* note: need to save size constraint for use in alignCharStr     */
+   /* because it will be cleared in decodeLength from the context..        */
+   Asn1SizeCnst* psize = pctxt->pSizeConstraint;
+
+   /* Decode length */
+
+   stat = decodeLength (pctxt, &len);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Byte-align */
+
+   if (alignCharStr (pctxt, len, nbits, psize)) {
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+   }
+
+   /* Decode data */
+
+   tmpstr = (char*) ASN1MALLOC (pctxt, len+1);
+   if (0 != tmpstr) {
+      if (nbits >= canSetBits && canSetBits > 4) {
+         for (i = 0; i < len; i++) {
+            if ((stat = decodeBits (pctxt, &idx, nbits)) == ASN_OK) {
+               tmpstr[i] = (char) idx;
+            }
+            else break;
+         }
+      }
+      else if (0 != charSet) {
+         ASN1UINT nchars = strlen (charSet);
+         for (i = 0; i < len; i++) {
+            if ((stat = decodeBits (pctxt, &idx, nbits)) == ASN_OK) {
+               if (idx < nchars) {
+                  tmpstr[i] = charSet[idx];
+               }
+               else return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO);
+            }
+            else break;
+         }
+      }
+      else stat = ASN_E_INVPARAM;
+
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      tmpstr[i] = '\0';  /* add null-terminator */
+   }
+   else
+      return LOG_ASN1ERR (pctxt, ASN_E_NOMEM);
+
+   *string = tmpstr;
+
+   return ASN_OK;
+}
+
+int decodeConsInteger 
+(OOCTXT* pctxt, ASN1INT* pvalue, ASN1INT lower, ASN1INT upper)
+{ 
+   ASN1UINT range_value = upper - lower;
+   ASN1UINT adjusted_value;
+   int stat = ASN_OK;
+
+   if (range_value != ASN1UINT_MAX) { range_value += 1; }
+
+   if (lower > upper)
+      return ASN_E_RANGERR;
+   else if (lower != upper) {
+      stat = decodeConsWholeNumber (pctxt, &adjusted_value, range_value);
+      if (stat == ASN_OK) {
+         *pvalue = adjusted_value + lower;
+
+         if (*pvalue < lower || *pvalue > upper)
+            stat = ASN_E_CONSVIO;
+      }
+   }
+   else {
+      *pvalue = lower;
+   }
+
+   return stat;
+}
+
+int decodeConsUInt8 
+(OOCTXT* pctxt, ASN1UINT8* pvalue, ASN1UINT lower, ASN1UINT upper)
+{ 
+   ASN1UINT range_value, value;
+   ASN1UINT adjusted_value;
+   int stat = ASN_OK;
+
+   /* Check for special case: if lower is 0 and upper is ASN1UINT_MAX,  */
+   /* set range to ASN1UINT_MAX; otherwise to upper - lower + 1         */
+
+   range_value = (lower == 0 && upper == ASN1UINT_MAX) ?
+      ASN1UINT_MAX : upper - lower + 1;
+
+   if (lower != upper) {
+      ASN1UINT range_bitcnt;
+
+      /* If range is <= 255, bit-field case (10.5.7a) */
+
+      if (range_value <= 255) {
+         range_bitcnt = getUIntBitCount (range_value - 1);
+      }
+
+      /* If range is exactly 256, one-octet case (10.5.7b) */
+
+      else if (range_value == 256) {
+         stat = decodeByteAlign (pctxt);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         range_bitcnt = 8;
+      }
+      stat = decodeBits (pctxt, &adjusted_value, range_bitcnt);
+      if (stat == ASN_OK) {
+         value = adjusted_value + lower;
+
+         if (value < lower || value > upper)
+            stat = ASN_E_CONSVIO;
+
+         *pvalue = (ASN1OCTET)value;
+      }
+   }
+   else *pvalue = (ASN1OCTET)lower;
+
+   return stat;
+}
+
+int decodeConsUInt16 
+(OOCTXT* pctxt, ASN1USINT* pvalue, ASN1UINT lower, ASN1UINT upper)
+{ 
+   ASN1UINT range_value, value;
+   ASN1UINT adjusted_value;
+   int stat = ASN_OK;
+
+   /* Check for special case: if lower is 0 and upper is ASN1UINT_MAX,  */
+   /* set range to ASN1UINT_MAX; otherwise to upper - lower + 1         */
+
+   range_value = (lower == 0 && upper == ASN1UINT_MAX) ?
+      ASN1UINT_MAX : upper - lower + 1;
+
+   if (lower != upper) {
+      stat = decodeConsWholeNumber (pctxt, &adjusted_value, range_value);
+      if (stat == ASN_OK) {
+         value = adjusted_value + lower;
+
+         /* Verify value is within given range (ED, 1/15/2002) */
+         if (value < lower || value > upper)
+            stat = ASN_E_CONSVIO;
+         *pvalue = (ASN1USINT) value;
+      }
+   }
+   else *pvalue = (ASN1USINT) lower;
+
+   return stat;
+}
+
+int decodeConsUnsigned 
+(OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT lower, ASN1UINT upper)
+{ 
+   ASN1UINT range_value;
+   ASN1UINT adjusted_value;
+   int stat = ASN_OK;
+
+   /* Check for special case: if lower is 0 and upper is ASN1UINT_MAX,  */
+   /* set range to ASN1UINT_MAX; otherwise to upper - lower + 1         */
+
+   range_value = (lower == 0 && upper == ASN1UINT_MAX) ?
+      ASN1UINT_MAX : upper - lower + 1;
+
+   if (lower != upper) {
+      stat = decodeConsWholeNumber (pctxt, &adjusted_value, range_value);
+      if (stat == ASN_OK) {
+         *pvalue = adjusted_value + lower;
+         if (*pvalue < lower || *pvalue > upper)
+            stat = ASN_E_CONSVIO;
+      }
+   }
+   else *pvalue = lower;
+
+   return stat;
+}
+
+int decodeConsWholeNumber 
+(OOCTXT* pctxt, ASN1UINT* padjusted_value, ASN1UINT range_value)
+{ 
+   ASN1UINT nocts, range_bitcnt;
+   int stat;
+
+   /* If unaligned, decode non-negative binary integer in the minimum   */
+   /* number of bits necessary to represent the range (10.5.6)          */
+
+   if (!TRUE) {
+      range_bitcnt = getUIntBitCount (range_value - 1);
+   }
+
+   /* If aligned, encoding depended on range value (10.5.7) */
+
+   else {  /* aligned */
+
+      /* If range is <= 255, bit-field case (10.5.7a) */
+
+      if (range_value <= 255) {
+         range_bitcnt = getUIntBitCount (range_value - 1);
+      }
+
+      /* If range is exactly 256, one-octet case (10.5.7b) */
+
+      else if (range_value == 256) {
+         stat = decodeByteAlign (pctxt);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         range_bitcnt = 8;
+      }
+
+      /* If range > 256 and <= 64k (65535), two-octet case (10.5.7c) */
+
+      else if (range_value <= 65536) {
+         stat = decodeByteAlign (pctxt);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         range_bitcnt = 16;
+      }
+
+      /* If range > 64k, indefinite-length case (10.5.7d) */
+
+      else {
+         stat = decodeBits (pctxt, &nocts, 2);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         stat = decodeByteAlign (pctxt);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         range_bitcnt = (nocts + 1) * 8;
+      }
+   }
+
+   return decodeBits (pctxt, padjusted_value, range_bitcnt);
+}
+
+int decodeDynBitString (OOCTXT* pctxt, ASN1DynBitStr* pBitStr)
+{
+   ASN1UINT nocts;
+   ASN1OCTET* ptmp;
+   int nbits, stat = ASN_OK;
+
+   /* If "fast copy" option is not set (ASN1FATSCOPY) or if constructed,
+    * copy the bit string value into a dynamic memory buffer;
+    * otherwise, store the pointer to the value in the decode 
+    * buffer in the data pointer argument. */
+   
+   if (pctxt->flags & ASN1FASTCOPY) {
+      /* check is it possible to do optimized decoding */
+
+      ASN1OCTET bit;
+      ASN1UINT byteIndex = pctxt->buffer.byteIndex;  /* save byte index */
+      ASN1USINT bitOffset = pctxt->buffer.bitOffset; /* save bit offset */
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      stat = DECODEBIT (pctxt, &bit); /* read first bit of length determinant */
+      if (bit == 1 && stat == ASN_OK) 
+         stat = DECODEBIT (pctxt, &bit); /* read second bit */
+
+      pctxt->buffer.byteIndex = byteIndex;  /* restore byte index */
+      pctxt->buffer.bitOffset = bitOffset;  /* restore bit offset */
+
+      /* if either first or second bit != 0 - not fragmented */
+
+      if (bit == 0 && stat == ASN_OK) { 
+         ASN1UINT bitcnt;
+         
+         stat = decodeLength (pctxt, &bitcnt);
+         if (stat != 0) return LOG_ASN1ERR (pctxt, stat);
+
+         pBitStr->numbits = bitcnt;
+         if (bitcnt > 0) {
+            pBitStr->data = ASN1BUFPTR (pctxt);
+
+            stat = moveBitCursor (pctxt, bitcnt);
+            if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+         }
+         else 
+            pBitStr->data = 0;
+   
+         return stat;
+      }
+   }
+
+   nbits = getComponentLength (pctxt, 1);
+
+   if (nbits < 0) return LOG_ASN1ERR (pctxt, nbits);
+   else if (nbits == 0) {
+      pBitStr->numbits = 0;
+      ptmp = 0;
+   }
+
+   nocts = (nbits + 7) / 8;
+      
+   /* Allocate memory for the target string */
+
+   if (nocts > 0) {
+      ptmp = (ASN1OCTET*) ASN1MALLOC (pctxt, nocts);
+      if (0 == ptmp) return LOG_ASN1ERR (pctxt, ASN_E_NOMEM);
+      
+      /* Call static bit string decode function */
+
+      stat = decodeBitString (pctxt, &pBitStr->numbits, ptmp, nocts);
+   }
+   pBitStr->data = ptmp;
+
+   return stat;
+}
+
+int decodeDynOctetString (OOCTXT* pctxt, ASN1DynOctStr* pOctStr)
+{
+   ASN1OCTET* ptmp;
+   int nocts, stat;
+
+   /* If "fast copy" option is not set (ASN1FASTCOPY) or if constructed,
+    * copy the octet string value into a dynamic memory buffer;
+    * otherwise, store the pointer to the value in the decode 
+    * buffer in the data pointer argument. */
+
+   if (pctxt->flags & ASN1FASTCOPY) {
+      /* check if it is possible to do optimized decoding */
+
+      ASN1OCTET bit;
+      ASN1UINT byteIndex = pctxt->buffer.byteIndex;  /* save byte index */
+      ASN1USINT bitOffset = pctxt->buffer.bitOffset; /* save bit offset */
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      stat = DECODEBIT (pctxt, &bit); /* read first bit of length determinant */
+      if (bit == 1 && stat == ASN_OK) 
+         stat = DECODEBIT (pctxt, &bit); /* read second bit */
+
+      pctxt->buffer.byteIndex = byteIndex;  /* restore byte index */
+      pctxt->buffer.bitOffset = bitOffset;  /* restore bit offset */
+
+      /* if either first or second bit != 0 - not fragmented */
+
+      if (bit == 0 && stat == ASN_OK) { 
+         ASN1UINT octcnt;
+         
+         stat = decodeLength (pctxt, &octcnt);
+         if (stat != 0) return LOG_ASN1ERR (pctxt, stat);
+
+         pOctStr->numocts = octcnt;
+         if (octcnt > 0) {
+            pOctStr->data = ASN1BUFPTR (pctxt);
+
+            stat = moveBitCursor (pctxt, octcnt * 8);
+            if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+         }
+         else 
+            pOctStr->data = 0;
+         
+         return stat;
+      }
+   }
+   
+   nocts = getComponentLength (pctxt, 8);
+
+   if (nocts < 0) return LOG_ASN1ERR (pctxt, nocts);
+   else if (nocts == 0) {
+      pOctStr->numocts = 0;
+      ptmp = 0;
+   }
+
+   /* Allocate memory for the target string */
+
+   else {
+      ptmp = (ASN1OCTET*) ASN1MALLOC (pctxt, nocts);
+      if (0 == ptmp) return LOG_ASN1ERR (pctxt, ASN_E_NOMEM);
+   }
+
+   /* Call static octet string decode function */
+
+   stat = decodeOctetString (pctxt, &pOctStr->numocts, ptmp, nocts);
+
+   pOctStr->data = ptmp;
+
+   return stat;
+}
+
+int decodeLength (OOCTXT* pctxt, ASN1UINT* pvalue)
+{
+   Asn1SizeCnst* pSize;
+   ASN1UINT lower, upper;
+   ASN1BOOL bitValue, extbit;
+   int      stat;
+
+   /* If size constraint is present and extendable, decode extension    */
+   /* bit..                                                             */
+
+   if (isExtendableSize(pctxt->pSizeConstraint)) {
+      stat = DECODEBIT (pctxt, &extbit);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+   }
+   else extbit = 0;
+
+   /* Now use the value of the extension bit to select the proper       */
+   /* size constraint range specification..                             */
+
+   pSize = getSizeConstraint (pctxt, extbit);
+
+   lower = (pSize) ? pSize->lower : 0;
+   upper = (pSize) ? pSize->upper : ASN1UINT_MAX;
+
+   /* Reset the size constraint in the context block structure */
+
+   pctxt->pSizeConstraint = 0;
+
+   /* If upper limit is less than 64k, constrained case */
+
+   if (upper < 65536) {
+      if (lower == upper) {
+         *pvalue = 0;
+         stat = ASN_OK;
+      }
+      else
+         stat = decodeConsWholeNumber (pctxt, pvalue, (upper - lower + 1));
+
+      if (stat == ASN_OK) *pvalue += lower;
+   }
+   else {
+      /* unconstrained case OR constrained with upper bound >= 64K*/
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      stat = DECODEBIT (pctxt, &bitValue);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      if (bitValue == 0) {
+         stat = decodeBits (pctxt, pvalue, 7);   /* 10.9.3.6 */
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+      }
+      else {
+         stat = DECODEBIT (pctxt, &bitValue);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         if (bitValue == 0) {
+            stat = decodeBits (pctxt, pvalue, 14);  /* 10.9.3.7 */
+            if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+         }
+         else {
+            ASN1UINT multiplier;
+
+            stat = decodeBits (pctxt, &multiplier, 6);
+            if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+            *pvalue = 16384 * multiplier;
+
+            stat = ASN_OK_FRAG;
+         }
+      }
+   }
+
+   return stat;
+}
+
+int decodeObjectIdentifier (OOCTXT* pctxt, ASN1OBJID* pvalue)
+{
+   ASN1UINT  len;
+   int       stat, j;
+   unsigned  subid;
+   ASN1UINT  b;
+
+   /* Decode unconstrained length */
+
+   if ((stat = decodeLength (pctxt, &len)) < 0) {
+      return LOG_ASN1ERR (pctxt, stat);
+   }
+
+   /* Copy contents to a byte-aligned local buffer */
+
+   j = 0;
+   while (len > 0 && stat == ASN_OK) {
+      if (j < ASN_K_MAXSUBIDS) {
+
+         /* Parse a subidentifier out of the contents field */
+
+         pvalue->subid[j] = 0;
+         do {
+            if ((stat = decodeBits (pctxt, &b, 8)) == ASN_OK) {
+               pvalue->subid[j] = (pvalue->subid[j] * 128) + (b & 0x7F);
+               len--;
+            }
+         } while (b & 0x80 && stat == ASN_OK);
+
+         /* Handle the first subidentifier special case: the first two   */
+         /* sub-id's are encoded into one using the formula (x * 40) + y */
+
+         if (j == 0) {
+            subid = pvalue->subid[0];
+            pvalue->subid[0] = ((subid / 40) >= 2) ? 2 : subid / 40;
+            pvalue->subid[1] = (pvalue->subid[0] == 2) ? 
+               subid - 80 : subid % 40;
+            j = 2;
+         }
+         else j++;
+      }
+      else
+         stat = ASN_E_INVOBJID; 
+   }
+
+   pvalue->numids = j;
+   if (stat == ASN_OK && len != 0) stat = ASN_E_INVLEN;
+
+   return (stat);
+}
+
+static int decodeOctets 
+(OOCTXT* pctxt, ASN1OCTET* pbuffer, ASN1UINT bufsiz, ASN1UINT nbits)
+{ 
+   ASN1UINT nbytes = (nbits + 7) / 8 ;
+   ASN1UINT i = 0, j;
+   ASN1UINT rshift = pctxt->buffer.bitOffset;
+   ASN1UINT lshift = 8 - rshift;
+   ASN1UINT nbitsInLastOctet;
+   ASN1OCTET mask;
+   int stat;
+
+   /* Check to make sure buffer contains number of bits requested */
+
+   if ((pctxt->buffer.byteIndex + nbytes) > pctxt->buffer.size) {
+      return LOG_ASN1ERR (pctxt, ASN_E_ENDOFBUF);
+   }
+
+   /* Check to make sure buffer is big enough to hold requested         */
+   /* number of bits..                                                  */
+
+   if (nbytes > bufsiz) {
+      return LOG_ASN1ERR (pctxt, ASN_E_STROVFLW);
+   }
+
+   /* If on a byte boundary, can do a direct memcpy to target buffer */
+
+   if (pctxt->buffer.bitOffset == 8) {
+      memcpy (pbuffer, &pctxt->buffer.data[pctxt->buffer.byteIndex], nbytes);
+      stat = moveBitCursor (pctxt, nbits);
+      if (stat != ASN_OK) return stat;
+      i = nbytes - 1; nbits %= 8;
+   }
+   else {
+      while (nbits >= 8) {
+
+         /* Transfer lower bits from stream octet to upper bits of      */
+         /* target octet..                                              */
+
+         pbuffer[i] = pctxt->buffer.data[pctxt->buffer.byteIndex++]
+            << lshift;
+
+         /* Transfer upper bits from next stream octet to lower bits    */
+         /* target octet..                                              */
+
+         pbuffer[i++] |= pctxt->buffer.data[pctxt->buffer.byteIndex]
+            >> rshift;
+
+         nbits -= 8;
+      }
+
+      /* Copy last partial byte */
+
+      if (nbits >= rshift) {
+         pbuffer[i] = 
+            pctxt->buffer.data[pctxt->buffer.byteIndex++] << lshift;
+
+         nbitsInLastOctet = nbits - rshift;
+
+         if (nbitsInLastOctet > 0) {
+            pbuffer[i] |= 
+               pctxt->buffer.data[pctxt->buffer.byteIndex] >> rshift;
+         }
+
+         pctxt->buffer.bitOffset = 8 - nbitsInLastOctet;
+      }
+      else if (nbits > 0) {  /* nbits < rshift */
+         pbuffer[i] = 
+            pctxt->buffer.data[pctxt->buffer.byteIndex] << lshift;
+         pctxt->buffer.bitOffset = rshift - nbits;
+      }
+   }
+
+   /* Mask unused bits off of last byte */
+
+   if (nbits > 0) {
+      mask = 0;
+      for (j = 0; j < nbits; j++) {
+         mask >>= 1;
+         mask |= 0x80;
+      }
+      pbuffer[i] &= mask;
+   }
+
+   return ASN_OK;
+}
+
+int decodeOctetString 
+(OOCTXT* pctxt, ASN1UINT* numocts_p, ASN1OCTET* buffer, ASN1UINT bufsiz)
+{
+   ASN1UINT octcnt;
+   int lstat, octidx = 0, stat;
+   Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint;
+
+   for (*numocts_p = 0;;) {
+      lstat = decodeLength (pctxt, &octcnt);
+      if (lstat < 0) return LOG_ASN1ERR (pctxt, lstat);
+
+      if (octcnt > 0) {
+         *numocts_p += octcnt;
+
+         if (TRUE) {
+            ASN1BOOL doAlign;
+
+            stat = bitAndOctetStringAlignmentTest 
+               (pSizeList, octcnt, FALSE, &doAlign);
+            if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+            if (doAlign) {
+               stat = decodeByteAlign (pctxt);
+               if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+            }
+         }
+
+         stat = decodeOctets (pctxt, &buffer[octidx], 
+                           bufsiz - octidx, (octcnt * 8));
+
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+      }
+
+      if (lstat == ASN_OK_FRAG) {
+         octidx += octcnt;
+      }
+      else break;
+   }
+
+   return ASN_OK;
+}
+
+int decodeOpenType 
+(OOCTXT* pctxt, const ASN1OCTET** object_p2, ASN1UINT* numocts_p)
+{
+   ASN1DynOctStr octStr;
+   int stat;
+
+   stat = decodeDynOctetString (pctxt, &octStr);
+   if (stat == ASN_OK) {
+      *numocts_p = octStr.numocts;
+      *object_p2 = octStr.data;
+   }
+
+   return stat;
+}
+
+int decodeSemiConsInteger (OOCTXT* pctxt, ASN1INT* pvalue, ASN1INT lower)
+{
+   signed char b;
+   unsigned char ub;
+   ASN1UINT nbytes;
+   int stat;
+
+   stat = decodeLength (pctxt, &nbytes);
+   if (stat < 0) return LOG_ASN1ERR (pctxt, stat);
+
+   if (nbytes > 0) {
+
+      /* Align buffer */
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      /* Decode first byte into a signed byte value and assign to integer. */
+      /* This should handle sign extension..                               */
+
+      stat = decodeOctets (pctxt, (ASN1OCTET*)&b, 1, 8);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      *pvalue = b;
+      nbytes--;
+
+      /* Decode remaining bytes and add to result */
+
+      while (nbytes > 0) {
+         stat = decodeOctets (pctxt, (ASN1OCTET*)&ub, 1, 8);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         *pvalue = (*pvalue * 256) + ub;
+         nbytes--;
+      }
+   }
+   else {  /* nbytes == 0 */
+      *pvalue = 0;
+   }
+   if (lower > ASN1INT_MIN)
+      *pvalue += lower;
+
+   return ASN_OK;
+}
+
+int decodeSemiConsUnsigned (OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT lower)
+{
+   ASN1UINT nbytes;
+   int stat;
+
+   stat = decodeLength (pctxt, &nbytes);
+   if (stat < 0) return LOG_ASN1ERR (pctxt, stat);
+
+   
+   if (nbytes > 0) {
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      stat = decodeBits (pctxt, pvalue, nbytes * 8);
+   }
+   else
+      *pvalue = 0;
+   *pvalue += lower;
+
+   return stat;
+}
+
+int decodeSmallNonNegWholeNumber (OOCTXT* pctxt, ASN1UINT* pvalue)
+{ 
+   ASN1BOOL bitValue;
+   ASN1UINT len;
+   int ret;
+
+   if ((ret = DECODEBIT (pctxt, &bitValue)) != ASN_OK)
+      return ret;
+
+   if (bitValue == 0) {
+      return decodeBits (pctxt, pvalue, 6);   /* 10.6.1 */
+   }
+   else {
+      if ((ret = decodeLength (pctxt, &len)) < 0)
+         return ret;
+
+      if ((ret = decodeByteAlign (pctxt)) != ASN_OK)
+         return ret;
+
+      return decodeBits (pctxt, pvalue, len*8);
+   }
+}
+
+int decodeVarWidthCharString (OOCTXT* pctxt, const char** pvalue)
+{
+   int        stat;
+   ASN1OCTET* tmpstr;
+   ASN1UINT   len;
+
+   /* note: need to save size constraint for use in alignCharStr     */
+   /* because it will be cleared in decodeLength from the context..        */
+   Asn1SizeCnst* psize = pctxt->pSizeConstraint;
+
+   /* Decode length */
+
+   stat = decodeLength (pctxt, &len);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Byte-align */
+
+   if (alignCharStr (pctxt, len, 8, psize)) {
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+   }
+
+   /* Decode data */
+
+   tmpstr = (ASN1OCTET*) ASN1MALLOC (pctxt, len + 1);
+   if (0 != tmpstr) {
+      if ((stat = decodeOctets (pctxt, tmpstr, len, len * 8)) != ASN_OK)
+         return LOG_ASN1ERR (pctxt, stat);
+
+      tmpstr[len] = '\0';  /* add null-terminator */
+   }
+   else
+      return LOG_ASN1ERR (pctxt, ASN_E_NOMEM);
+
+   *pvalue = (char*)tmpstr;
+
+   return ASN_OK;
+}
+
+static int decode16BitConstrainedString 
+(OOCTXT* pctxt, Asn116BitCharString* pString, Asn116BitCharSet* pCharSet)
+{
+   ASN1UINT i, idx, nbits = pCharSet->alignedBits;
+   int stat;
+
+   /* Decode length */
+
+   stat = decodeLength (pctxt, &pString->nchars);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Byte-align */
+
+   stat = decodeByteAlign (pctxt);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Decode data */
+
+   pString->data = (ASN116BITCHAR*)
+      ASN1MALLOC (pctxt, pString->nchars*sizeof(ASN116BITCHAR));
+
+   if (pString->data) {
+      for (i = 0; i < pString->nchars; i++) {
+         stat = decodeBits (pctxt, &idx, nbits);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         pString->data[i] = (pCharSet->charSet.data == 0) ? 
+            idx + pCharSet->firstChar : pCharSet->charSet.data[idx];
+      }
+   }
+   else
+      return LOG_ASN1ERR (pctxt, ASN_E_NOMEM);
+
+   return ASN_OK;
+}
+
+static int getComponentLength (OOCTXT* pctxt, ASN1UINT itemBits)
+{
+   OOCTXT lctxt;
+   ASN1UINT len, totalLen = 0;
+   int stat;
+
+   stat = initSubContext (&lctxt, pctxt);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+   if (stat != ASN_OK) {
+      freeContext (&lctxt);
+      return LOG_ASN1ERR (pctxt, stat);
+   }
+   lctxt.pSizeConstraint = pctxt->pSizeConstraint;
+
+   for (;;) {
+      stat = decodeLength (&lctxt, &len);
+      if (stat < 0) {
+         freeContext (&lctxt);
+         return LOG_ASN1ERR (pctxt, stat);
+      }
+
+      totalLen += len;
+
+      if (stat == ASN_OK_FRAG) {
+         stat = moveBitCursor (&lctxt, len * itemBits);
+         if (stat != ASN_OK) {
+            freeContext (&lctxt);
+            return LOG_ASN1ERR (pctxt, stat);
+         }
+      }
+      else break;
+   }
+
+   freeContext (&lctxt);
+
+   return totalLen;
+}
+
+int moveBitCursor (OOCTXT* pctxt, int bitOffset)
+{
+   int currBitOffset =
+      (pctxt->buffer.byteIndex * 8) + (8 - pctxt->buffer.bitOffset);
+
+   currBitOffset += bitOffset;
+
+   pctxt->buffer.byteIndex = (currBitOffset / 8);
+   pctxt->buffer.bitOffset = 8 - (currBitOffset % 8);
+
+   if (pctxt->buffer.byteIndex > pctxt->buffer.size) {
+      return (ASN_E_ENDOFBUF);
+   }
+      
+   return ASN_OK;
+}
diff --git a/addons/ooh323c/src/dlist.c b/addons/ooh323c/src/dlist.c
new file mode 100644
index 000000000..52fc87d42
--- /dev/null
+++ b/addons/ooh323c/src/dlist.c
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooasn1.h"
+
+void dListInit (DList* pList)
+{
+   if (pList) {
+      pList->count = 0;
+      pList->head = (DListNode*) 0;
+      pList->tail = (DListNode*) 0;
+   }
+}
+
+DListNode* dListAppend (OOCTXT* pctxt, DList* pList, void* pData)
+{
+   DListNode* pListNode = (DListNode*) 
+      memAlloc (pctxt, sizeof(DListNode));
+
+   if (0 != pListNode) {
+      pListNode->data = pData;
+      pListNode->next = (DListNode*) 0;
+      if (0 != pList->tail) {
+         pList->tail->next = pListNode;
+         pListNode->prev = pList->tail;
+      }
+      if (0 == pList->head) {
+         pList->head = pListNode;
+         pListNode->prev = (DListNode*) 0;
+      }
+      pList->tail = pListNode;
+      pList->count++;
+   }
+
+   return pListNode;
+}
+
+DListNode* dListAppendNode (OOCTXT* pctxt, DList* pList, void* pData)
+{
+   DListNode* pListNode = 
+      (DListNode*) (((char*)pData) - sizeof(DListNode));
+
+   if (0 != pListNode) {
+      pListNode->data = pData;
+      pListNode->next = (DListNode*) 0;
+      if (0 != pList->tail) {
+         pList->tail->next = pListNode;
+         pListNode->prev = pList->tail;
+      }
+      if (0 == pList->head) {
+         pList->head = pListNode;
+         pListNode->prev = (DListNode*) 0;
+      }
+      pList->tail = pListNode;
+      pList->count++;
+   }
+
+   return pListNode;
+}
+
+/* Delete the head node from the list and return the data item stored	*/
+/* in that node..							*/
+
+void* dListDeleteHead (OOCTXT* pctxt, DList* pList)
+{
+   DListNode* pNode = (0 != pList) ? pList->head : 0;
+   if (0 != pNode) {
+      void* pdata = pNode->data;
+      dListRemove (pList, pNode);
+      memFreePtr (pctxt, pNode);
+      return pdata;
+   }
+   return 0;
+}
+
+/* Free all nodes, but not the data */
+void dListFreeNodes (OOCTXT* pctxt, DList* pList)
+{
+   DListNode* pNode, *pNextNode;
+
+   for (pNode = pList->head; pNode != 0; pNode = pNextNode) {
+      pNextNode = pNode->next;
+      memFreePtr (pctxt, pNode);
+   }
+   pList->count = 0;
+   pList->head = pList->tail = 0;
+}
+
+/* Free all nodes and their data */
+void dListFreeAll (OOCTXT* pctxt, DList* pList)
+{
+   DListNode* pNode, *pNextNode;
+
+   for (pNode = pList->head; pNode != 0; pNode = pNextNode) {
+      pNextNode = pNode->next;
+      
+      memFreePtr (pctxt, pNode->data);
+      memFreePtr (pctxt, pNode);
+   }
+   pList->count = 0;
+   pList->head = pList->tail = 0;
+}
+
+/* Remove node from list. Node is not freed */
+void dListRemove (DList* pList, DListNode* node)
+{
+   if(node->next != 0) {
+      node->next->prev = node->prev;
+   }
+   else { /* tail */
+      pList->tail = node->prev;
+   }
+   if(node->prev != 0) {
+      node->prev->next = node->next;
+   }
+   else { /* head */
+      pList->head = node->next;
+   }
+   pList->count--;
+}
+
+void dListFindAndRemove(DList* pList, void *data)
+{
+   DListNode *pNode, *pNextNode;
+   for(pNode = pList->head; pNode !=0; pNode = pNextNode){
+      pNextNode = pNode->next;
+      if(pNode->data == data) /* pointer comparison*/
+         break;
+   }
+   if(pNode)
+      dListRemove(pList, pNode);
+}
+    
+DListNode* dListFindByIndex (DList* pList, int index) 
+{
+   DListNode* curNode;
+   int i;
+
+   if(index >= (int)pList->count) return 0;
+   for(i = 0, curNode = pList->head; i < index && curNode != 0; i++) {
+      curNode = curNode->next;
+   }
+   return curNode;
+}
+
+/* Insert item before given node */
+
+DListNode* dListInsertBefore 
+(OOCTXT* pctxt, DList* pList, DListNode* node, const void* pData)
+{
+   DListNode* pListNode = (DListNode*) memAlloc (pctxt, sizeof(DListNode));
+  
+   if (0 != pListNode) {
+      pListNode->data = (void*)pData;
+
+      if (node == 0) { /* insert before end (as last element) */
+         pListNode->next = (DListNode*) 0;
+         if (0 != pList->tail) {
+            pList->tail->next = pListNode;
+            pListNode->prev = pList->tail;
+         }
+         if (0 == pList->head) {
+            pList->head = pListNode;
+            pListNode->prev = (DListNode*) 0;
+         }
+         pList->tail = pListNode;
+      }
+      else if (node == pList->head) { /* insert as head (head case) */
+         pListNode->next = pList->head;
+         pListNode->prev = (DListNode*) 0;
+         if(pList->head != 0) {
+            pList->head->prev = pListNode;
+         }
+         if(pList->tail == 0) {
+            pList->tail = pListNode;
+         }
+         pList->head = pListNode;
+      }
+      else { /* other cases */
+         pListNode->next = node;
+         pListNode->prev = node->prev;
+         node->prev = pListNode;
+         /* here, pListNode->prev always should be non-zero,
+          * because if pListNode->prev is zero - it is head case (see above).
+          */
+         pListNode->prev->next = pListNode;
+      }
+
+      pList->count++;
+   }
+
+   return pListNode;
+}
+
+/* Insert item after given node */
+
+DListNode* dListInsertAfter 
+(OOCTXT* pctxt, DList* pList, DListNode* node, const void* pData)
+{
+   DListNode* pListNode = (DListNode*) memAlloc (pctxt, sizeof(DListNode));
+
+   if (0 != pListNode) {
+      pListNode->data = (void*)pData;
+
+      if (node == 0) { /* insert as head (as first element) */
+         pListNode->next = pList->head;
+         pListNode->prev = (DListNode*) 0;
+         if (pList->head != 0) {
+            pList->head->prev = pListNode;
+         }
+         if (pList->tail == 0) {
+            pList->tail = pListNode;
+         }
+         pList->head = pListNode;
+      }
+      else if (node == pList->tail) { /* insert as tail (as last element) */
+         pListNode->next = (DListNode*) 0;
+         if (0 != pList->tail) {
+            pList->tail->next = pListNode;
+            pListNode->prev = pList->tail;
+         }
+         if (0 == pList->head) {
+            pList->head = pListNode;
+            pListNode->prev = (DListNode*) 0;
+         }
+         pList->tail = pListNode;
+      }
+      else { /* other cases */
+         pListNode->next = node->next;
+         pListNode->prev = node;
+         node->next = pListNode;
+         /* here, pListNode->next always should be non-zero,
+          * because if pListNode->next is zero - it is tail case (see above).
+          */
+         pListNode->next->prev = pListNode;
+      }
+
+      pList->count++;
+   }
+
+   return pListNode;
+}
+
diff --git a/addons/ooh323c/src/dlist.h b/addons/ooh323c/src/dlist.h
new file mode 100644
index 000000000..79663d999
--- /dev/null
+++ b/addons/ooh323c/src/dlist.h
@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/** 
+ * @file dlist.h 
+ * Doubly-linked list structures and utility functions.
+ */
+#ifndef _OODLIST_H_
+#define _OODLIST_H_
+
+struct OOCTXT;
+
+/**
+ * @defgroup llfuns Doubly-linked list structures and utility functions.
+ * @{
+ */
+typedef struct _DListNode {
+   void* data;
+   struct _DListNode* next;
+   struct _DListNode* prev;
+} DListNode;
+
+typedef struct _DList {
+   unsigned int count;
+   DListNode* head;
+   DListNode* tail;
+} DList;
+
+#define ALLOC_ASN1ELEMDNODE(pctxt,type) \
+(type*) (((char*)memHeapAllocZ (&(pctxt)->pTypeMemHeap, sizeof(type) + \
+sizeof(DListNode))) + sizeof(DListNode))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#if defined (MAKE_DLL)
+#define EXTERN __declspec(dllexport)
+#elif defined (USEASN1DLL)
+#define EXTERN __declspec(dllimport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+/**
+ * This function appends an item to the linked list structure. The data item is
+ * passed into the function as a void pointer that can point to any object of
+ * any type. The memAlloc function is used to allocated the memory for the
+ * list node structure; therefore, all internal list memory will be released
+ * whenever memFree is called. The pointer to the data item itself is stored
+ * in the node structure - a copy is not made.
+ *
+ * @param pctxt        A pointer to a context structure. This provides a
+ *                     storage area for the function to store all working
+ *                     variables that must be maintained between function
+ *                     calls.
+ * @param pList        A pointer to a linked list structure onto which the data
+ *                     item is to be appended. A pointer to an updated linked
+ *                     list structure.
+ * @param pData        A pointer to a data item to be appended to the list.
+ * @return             A pointer to an allocated node structure used to link
+ *                     the given data value into the list.
+ */ 
+EXTERN DListNode* dListAppend 
+(struct OOCTXT* pctxt, DList* pList, void* pData);
+
+EXTERN DListNode* dListAppendNode 
+(struct OOCTXT* pctxt, DList* pList, void* pData);
+
+/**
+ * This function delete the head item from the list and returns a pointer 
+ * the data item stored in that node.  The memory for the node structure 
+ * is released.
+ *
+ * @param pctxt        A pointer to a context structure. This provides a
+ *                     storage area for the function to store all working
+ *                     variables that must be maintained between function
+ *                     calls.
+ * @param pList        A pointer to the linked list structure from which 
+ *                     the node will be deleted.
+ * @return             A pointer to the data item stored in the deleted node.
+ */ 
+EXTERN void* dListDeleteHead (struct OOCTXT* pctxt, DList* pList);
+
+EXTERN DListNode* dListFindByIndex (DList* pList, int index);
+
+/**
+ * This function initializes a doubly linked list structure. It sets the number
+ * of elements to zero and sets all internal pointer values to NULL. A doubly
+ * linked-list structure is described by the DList type. Nodes of the list 
+ * are of type DListNode.
+ *
+ * Memory for the structures is allocated using the memAlloc run-time
+ * function and is maintained within the context structure that is a required
+ * parameter to all dList functions. This memory is released when memFree
+ * is called or the Context is released. Unless otherwise noted, all data
+ * passed into the list functions is simply stored on the list by value (i.e. a
+ * deep-copy of the data is not done).
+ *
+ * @param pList        A pointer to a linked list structure to be initialized.
+ */
+EXTERN void dListInit (DList* pList);
+
+/**
+ * This function removes all nodes from the linked list and releases the memory
+ * that was allocated for storing the node structures (DListNode). The data
+ * will not be released.
+ *
+ * @param pctxt        A pointer to a context structure. This provides a
+ *                     storage area for the function to store all working
+ *                     variables that must be maintained between function
+ *                     calls.
+ * @param pList        A pointer to a linked list structure onto which the data
+ *                     item is to be appended. A pointer to an updated linked
+ *                     list structure.
+ */
+EXTERN void dListFreeNodes (struct OOCTXT* pctxt, DList* pList);
+
+/** 
+ * This function removes all nodes from the linked list structure and releases
+ * the memory that was allocated for storing the node structures
+ * (DListNode) and for data. The memory for data in each node must have
+ * been previously allocated with calls to memAlloc, memAllocZ, or
+ * memRealloc functions.
+ *
+ * @param pctxt        Pointer to a context structure. This provides a
+ *                     storage area for the function to store all working
+ *                     variables that must be maintained between function
+ *                     calls.
+ * @param pList        Pointer to a linked list structure.
+ */
+EXTERN void dListFreeAll (struct OOCTXT* pctxt, DList* pList);
+
+/**
+ * This function inserts an item into the linked list structure before the 
+ * specified element.
+ * 
+ * @param pctxt         Pointer to a context structure.
+ * @param pList		A pointer to a linked list structure into which the 
+ *                        data item is to be inserted.
+ * @param node          The position in the list where the item is to be 
+ *                        inserted.  The item will be inserted before this 
+ *                        node or appended to the list if node is null.
+ * @param pData		A pointer to the data item to be inserted to the list.
+ * @return		A pointer to an allocated node structure used to 
+ *                        link the given data value into the list.
+ */
+EXTERN DListNode* dListInsertBefore 
+(struct OOCTXT* pctxt, DList* pList, DListNode* node, const void* pData);
+
+/**
+ * This function inserts an item into the linked list structure after the 
+ * specified element.
+ * 
+ * @param pctxt         Pointer to a context structure.
+ * @param pList		A pointer to a linked list structure into which the 
+ *                        data item is to be inserted.
+ * @param node          The position in the list where the item is to be 
+ *                        inserted.  The item will be inserted after this 
+ *                        node or added as the head element if node is null.
+ * @param pData		A pointer to the data item to be inserted to the list.
+ * @return		A pointer to an allocated node structure used to 
+ *                        link the given data value into the list.
+ */
+EXTERN DListNode* dListInsertAfter 
+(struct OOCTXT* pctxt, DList* pList, DListNode* node, const void* pData);
+
+/**
+ * This function removes a node from the linked list structure. The memAlloc
+ * function was used to allocate the memory for the list node structure,
+ * therefore, all internal list memory will be released whenever memFree or
+ * memFreePtr is called.
+ *
+ * @param pList        A pointer to a linked list structure onto which the data
+ *                     item is to be removed. A pointer to an updated linked
+ *                     list structure.
+ * @param node         A pointer to the node that is to be removed. It should
+ *                     already be in the linked list structure.
+ */
+EXTERN void  dListRemove (DList* pList, DListNode* node);
+void dListFindAndRemove(DList* pList, void* data);
+
+/** 
+ * @}
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/encode.c b/addons/ooh323c/src/encode.c
new file mode 100644
index 000000000..45e5916df
--- /dev/null
+++ b/addons/ooh323c/src/encode.c
@@ -0,0 +1,1103 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include <stdlib.h>
+#include "ooasn1.h"
+
+static int encode16BitConstrainedString 
+(OOCTXT* pctxt, Asn116BitCharString value, Asn116BitCharSet* pCharSet);
+
+static int encode2sCompBinInt (OOCTXT* pctxt, ASN1INT value);
+static int encodeNonNegBinInt (OOCTXT* pctxt, ASN1UINT value);
+static int encodeUnconsLength (OOCTXT* pctxt, ASN1UINT value);
+static int getIdentByteCount (ASN1UINT ident);
+
+int encodeBit (OOCTXT* pctxt, ASN1BOOL value)
+{ 
+   int stat = ASN_OK;
+
+   /* If start of new byte, init to zero */
+
+   if (pctxt->buffer.bitOffset == 8) {
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+   }
+
+   /* Adjust bit offset and determine if at end of current byte */
+
+   if (--pctxt->buffer.bitOffset < 0) {
+      if (++pctxt->buffer.byteIndex >= pctxt->buffer.size) {
+         if ((stat = encodeExpandBuffer (pctxt, 1)) != ASN_OK) {
+            return stat;
+         }
+      }
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+      pctxt->buffer.bitOffset = 7;
+   }
+
+   /* Set single-bit value */
+
+   if (value) {
+      pctxt->buffer.data[pctxt->buffer.byteIndex] |= 
+         ( 1 << pctxt->buffer.bitOffset );
+   }
+
+   /* If last bit in octet, set offsets to start new byte (ED, 9/7/01) */
+
+   if (pctxt->buffer.bitOffset == 0) {
+      pctxt->buffer.bitOffset = 8;
+      pctxt->buffer.byteIndex++;
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+   }
+
+   return stat;
+}
+
+int encodeBits (OOCTXT* pctxt, ASN1UINT value, ASN1UINT nbits)
+{ 
+   int nbytes = (nbits + 7)/ 8, stat = ASN_OK;
+
+   if (nbits == 0) return stat;
+
+   /* If start of new byte, init to zero */
+
+   if (pctxt->buffer.bitOffset == 8) {
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+   }
+
+   /* Mask off unused bits from the front of the value */
+
+   if (nbits < (sizeof(ASN1UINT) * 8))
+      value &= ((1 << nbits) - 1);
+
+   /* If bits will fit in current byte, set them and return */
+
+   if (nbits < (unsigned)pctxt->buffer.bitOffset) {
+      pctxt->buffer.bitOffset -= nbits;
+      pctxt->buffer.data[pctxt->buffer.byteIndex] |= 
+         ( value << pctxt->buffer.bitOffset );
+      return stat;
+   }
+
+   /* Check buffer space and allocate more memory if necessary */
+
+   stat = encodeCheckBuffer (pctxt, nbytes);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Set bits in remainder of the current byte and then loop   */
+   /* to set bits in subsequent bytes..                         */
+
+   nbits -= pctxt->buffer.bitOffset;
+   pctxt->buffer.data[pctxt->buffer.byteIndex++] |= 
+      (ASN1OCTET)( value >> nbits );
+   pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; 
+
+   while (nbits >= 8) {
+      nbits -= 8;
+      pctxt->buffer.data[pctxt->buffer.byteIndex++] = 
+         (ASN1OCTET)( value >> nbits );
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; 
+   }
+
+   /* copy final partial byte */
+
+   pctxt->buffer.bitOffset = 8 - nbits;
+   if (nbits > 0) {
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = 
+         (ASN1OCTET)((value & ((1 << nbits)-1)) << pctxt->buffer.bitOffset);
+   }
+   else
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+
+   return stat;
+}
+
+int encodeBitsFromOctet (OOCTXT* pctxt, ASN1OCTET value, ASN1UINT nbits)
+{ 
+   int lshift = pctxt->buffer.bitOffset;
+   int rshift = 8 - pctxt->buffer.bitOffset;
+   int stat = ASN_OK;
+   ASN1OCTET mask;
+
+   if (nbits == 0) return ASN_OK;
+
+   /* Mask off unused bits from the end of the value */
+
+   if (nbits < 8) {
+      switch (nbits) {
+      case 1: mask = 0x80; break;
+      case 2: mask = 0xC0; break;
+      case 3: mask = 0xE0; break;
+      case 4: mask = 0xF0; break;
+      case 5: mask = 0xF8; break;
+      case 6: mask = 0xFC; break;
+      case 7: mask = 0xFE; break;
+      default:;
+      }
+      value &= mask;
+   }
+
+   /* If we are on a byte boundary, we can do a direct assignment */
+
+   if (pctxt->buffer.bitOffset == 8) {
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = value;
+      if (nbits == 8) {
+         pctxt->buffer.byteIndex++;
+         pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+      }
+      else
+         pctxt->buffer.bitOffset -= nbits;
+   }
+
+   /* Otherwise, need to set some bits in the first octet and   */
+   /* possibly some bits in the following octet..               */
+
+   else {
+      pctxt->buffer.data[pctxt->buffer.byteIndex] |= 
+         (ASN1OCTET)(value >> rshift);
+
+      pctxt->buffer.bitOffset -= nbits;
+
+      if (pctxt->buffer.bitOffset < 0) {
+         pctxt->buffer.byteIndex++;
+         pctxt->buffer.data[pctxt->buffer.byteIndex] = 
+            (ASN1OCTET)(value << lshift);
+         pctxt->buffer.bitOffset += 8;
+      }
+   }
+
+   return stat;
+}
+
+int encodeBitString (OOCTXT* pctxt, ASN1UINT numbits, const ASN1OCTET* data)
+{
+   int enclen, octidx = 0, stat;
+   Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint;
+
+   for (;;) {
+      if ((enclen = encodeLength (pctxt, numbits)) < 0) {
+         return LOG_ASN1ERR (pctxt, enclen);
+      }
+
+      if (enclen > 0) {
+         ASN1BOOL doAlign;
+
+         stat = bitAndOctetStringAlignmentTest 
+            (pSizeList, numbits, TRUE, &doAlign);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         if (doAlign) {
+            stat = encodeByteAlign (pctxt);
+            if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+         }
+
+         stat = encodeOctets (pctxt, &data[octidx], enclen);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+      }
+
+      if (enclen < (int)numbits) {
+         numbits -= enclen;
+         octidx += (enclen/8);
+      }
+      else break;
+   }
+
+   return ASN_OK;
+}
+
+int encodeBMPString 
+(OOCTXT* pctxt, ASN1BMPString value, Asn116BitCharSet* permCharSet)
+{
+   Asn116BitCharSet charSet;
+   int stat;
+
+   /* Set character set */
+
+   init16BitCharSet (&charSet, BMP_FIRST, BMP_LAST, BMP_ABITS, BMP_UBITS);
+
+   if (permCharSet) {
+      set16BitCharSet (pctxt, &charSet, permCharSet);
+   }
+
+   /* Encode constrained string */
+
+   stat = encode16BitConstrainedString (pctxt, value, &charSet);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   return stat;
+}
+
+int encodeByteAlign (OOCTXT* pctxt)
+{
+   if (pctxt->buffer.bitOffset != 8) {
+      if ((pctxt->buffer.byteIndex + 1) >= pctxt->buffer.size) {
+         int stat = encodeExpandBuffer (pctxt, 1);
+         if (stat != ASN_OK) return (stat);
+      }
+      pctxt->buffer.byteIndex++;
+      pctxt->buffer.bitOffset = 8;
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+   }
+
+   return ASN_OK;
+}
+
+int encodeCheckBuffer (OOCTXT* pctxt, ASN1UINT nbytes)
+{
+   int stat = ASN_OK;
+
+   /* Add one to required bytes because increment logic will always     */
+   /* init the byte at the incremented index to zero..                  */
+
+   if ( ( pctxt->buffer.byteIndex + nbytes + 1 ) >= pctxt->buffer.size ) {
+      if ((stat = encodeExpandBuffer (pctxt, nbytes+1)) != ASN_OK) {
+         return LOG_ASN1ERR (pctxt, stat);
+      }
+   }
+
+   return (stat);
+}
+
+int encodeConsInteger 
+(OOCTXT* pctxt, ASN1INT value, ASN1INT lower, ASN1INT upper)
+{ 
+   ASN1UINT range_value;
+   ASN1UINT adjusted_value;
+   int stat;
+
+   /* Check value against given range */
+
+   if (value < lower || value > upper) {
+      return ASN_E_CONSVIO;
+   }
+
+   /* Adjust range value based on lower/upper signed values and */
+   /* other possible conflicts..                                */
+
+   if ((upper > 0 && lower >= 0) || (upper <= 0 && lower < 0)) {
+      range_value = upper - lower;
+      adjusted_value = value - lower;
+   }
+   else {
+      range_value = upper + abs(lower);
+      adjusted_value = value + abs(lower);
+   }      
+
+   if (range_value != ASN1UINT_MAX) { range_value += 1; }
+
+   if (range_value == 0 || lower > upper)
+      stat = ASN_E_RANGERR;
+   else if (lower != upper) {
+      stat = encodeConsWholeNumber (pctxt, adjusted_value, range_value);
+   }
+   else
+      stat = ASN_OK;
+
+   return stat;
+}
+
+int encodeConsUnsigned 
+(OOCTXT* pctxt, ASN1UINT value, ASN1UINT lower, ASN1UINT upper)
+{ 
+   ASN1UINT range_value;
+   ASN1UINT adjusted_value;
+   int stat;
+
+   /* Check for special case: if lower is 0 and upper is ASN1UINT_MAX,  */
+   /* set range to ASN1UINT_MAX; otherwise to upper - lower + 1         */
+
+   range_value = (lower == 0 && upper == ASN1UINT_MAX) ?
+      ASN1UINT_MAX : upper - lower + 1;
+
+   adjusted_value = value - lower;
+
+   if (lower != upper) {
+      stat = encodeConsWholeNumber (pctxt, adjusted_value, range_value);
+   }
+   else
+      stat = ASN_OK;
+
+   return stat;
+}
+
+int encodeConsWholeNumber 
+(OOCTXT* pctxt, ASN1UINT adjusted_value, ASN1UINT range_value)
+{ 
+   ASN1UINT nocts, range_bitcnt = getUIntBitCount (range_value - 1);
+   int stat;
+
+   if (adjusted_value >= range_value && range_value != ASN1UINT_MAX) {
+      return LOG_ASN1ERR (pctxt, ASN_E_RANGERR);
+   }
+
+   /* If range is <= 255, bit-field case (10.5.7a) */
+
+   if (range_value <= 255) {
+      return encodeBits (pctxt, adjusted_value, range_bitcnt);
+   }
+
+   /* If range is exactly 256, one-octet case (10.5.7b) */
+
+   else if (range_value == 256) {
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      return encodeBits (pctxt, adjusted_value, 8);
+   }
+
+   /* If range > 256 and <= 64k (65536), two-octet case (10.5.7c) */
+
+   else if (range_value <= 65536) {
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      return encodeBits (pctxt, adjusted_value, 16);
+   }
+
+   /* If range > 64k, indefinite-length case (10.5.7d) */
+
+   else {
+      /* Encode length determinant as a constrained whole number.    */
+      /* Constraint is 1 to max number of bytes needed to hold       */
+      /* the target integer value..                                  */
+
+      if (adjusted_value < 256) nocts = 1;
+      else if (adjusted_value < 65536) nocts = 2;
+      else if (adjusted_value < 0x1000000) nocts = 3;
+      else nocts = 4;
+
+      stat = encodeBits (pctxt, nocts - 1, 2);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      return encodeNonNegBinInt (pctxt, adjusted_value);
+   }
+}
+
+int encodeConstrainedStringEx (OOCTXT* pctxt, 
+                            const char* string, 
+                            const char* charSet,
+                            ASN1UINT abits,  /* aligned char bits */
+                            ASN1UINT ubits,  /* unaligned char bits */
+                            ASN1UINT canSetBits)
+{
+   ASN1UINT i, len = strlen(string);
+   int      stat;
+   /* note: need to save size constraint for use in alignCharStr     */
+   /* because it will be cleared in encodeLength from the context..        */
+   Asn1SizeCnst* psize = pctxt->pSizeConstraint;
+
+   /* Encode length */
+
+   stat = encodeLength (pctxt, len);
+   if (stat < 0) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Byte align */
+
+   if (alignCharStr (pctxt, len, abits, psize)) {
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+   }
+
+   /* Encode data */
+
+   if (abits >= canSetBits && canSetBits > 4) {
+      for (i = 0; i < len; i++) {
+         if ((stat = encodeBits (pctxt, string[i], abits)) != ASN_OK)
+            return LOG_ASN1ERR (pctxt, stat);
+      }
+   }
+   else if (0 != charSet) {
+      ASN1UINT nchars = strlen(charSet), pos;
+      const char* ptr;
+      for (i = 0; i < len; i++) {
+         ptr = memchr (charSet, string[i], nchars);
+
+         if (0 == ptr)
+            return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO);
+         else
+            pos = ptr - charSet;
+
+         if ((stat = encodeBits (pctxt, pos, abits)) != ASN_OK)
+            return LOG_ASN1ERR (pctxt, stat);
+      }
+   }
+   else return LOG_ASN1ERR (pctxt, ASN_E_INVPARAM);
+
+   return stat;
+}
+
+int encodeExpandBuffer (OOCTXT* pctxt, ASN1UINT nbytes)
+{
+   if (pctxt->buffer.dynamic)
+   {
+      /* If dynamic encoding is enabled, expand the current buffer to   */
+      /* allow encoding to continue.                                    */
+
+      pctxt->buffer.size += ASN1MAX (ASN_K_ENCBUFSIZ, nbytes);
+
+      pctxt->buffer.data = (ASN1OCTET*) memHeapRealloc
+         (&pctxt->pMsgMemHeap, pctxt->buffer.data, pctxt->buffer.size);
+      
+      if (!pctxt->buffer.data) return (ASN_E_NOMEM);
+
+      return (ASN_OK);
+   }
+
+   return (ASN_E_BUFOVFLW);
+}
+
+int encodeGetMsgBitCnt (OOCTXT* pctxt)
+{
+   int numBitsInLastByte = 8 - pctxt->buffer.bitOffset;
+   return ((pctxt->buffer.byteIndex * 8) + numBitsInLastByte);
+}
+
+ASN1OCTET* encodeGetMsgPtr (OOCTXT* pctxt, int* pLength)
+{
+   if (pLength) *pLength = getPERMsgLen (pctxt);
+   return pctxt->buffer.data;
+}
+
+int encodeIdent (OOCTXT* pctxt, ASN1UINT ident) 
+{
+   ASN1UINT mask;
+   int nshifts = 0, stat;
+
+   if (ident !=0) {
+      ASN1UINT lv;
+      nshifts = getIdentByteCount (ident);
+      while (nshifts > 0) {
+         mask = ((ASN1UINT)0x7f) << (7 * (nshifts - 1));
+         nshifts--;
+         lv = (ASN1UINT)((ident & mask) >> (nshifts * 7));
+         if (nshifts != 0) { lv |= 0x80; }
+         if ((stat = encodeBits (pctxt, lv, 8)) != ASN_OK)
+            return LOG_ASN1ERR (pctxt, stat);
+      }
+   }
+   else {
+      /* encode a single zero byte */
+      if ((stat = encodeBits (pctxt, 0, 8)) != ASN_OK)
+         return LOG_ASN1ERR (pctxt, stat);
+   }
+
+   return ASN_OK;
+}
+
+int encodeLength (OOCTXT* pctxt, ASN1UINT value)
+{ 
+   ASN1BOOL extendable;
+   Asn1SizeCnst* pSize = 
+      checkSize (pctxt->pSizeConstraint, value, &extendable);
+   ASN1UINT lower = (pSize) ? pSize->lower : 0;
+   ASN1UINT upper = (pSize) ? pSize->upper : ASN1UINT_MAX;
+   int enclen, stat;
+
+   /* If size constraints exist and the given length did not fall       */
+   /* within the range of any of them, signal constraint violation      */
+   /* error..                                                           */
+
+   if (pctxt->pSizeConstraint && !pSize) 
+      return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO);
+
+   /* Reset the size constraint in the context block structure */
+
+   pctxt->pSizeConstraint = 0;
+
+   /* If size constraint is present and extendable, encode extension    */
+   /* bit..                                                             */
+
+   if (extendable) {
+      stat = (pSize) ?
+         encodeBit (pctxt, pSize->extended) : encodeBit (pctxt, 1);
+
+      if (stat != ASN_OK) return (stat);
+   }
+
+   /* If upper limit is less than 64k, constrained case */
+
+   if (upper < 65536) {
+      stat = (lower == upper) ? ASN_OK :
+         encodeConsWholeNumber (pctxt, value - lower, upper - lower + 1);
+      enclen = (stat == ASN_OK) ? value : stat;
+   }
+   else {
+      /* unconstrained case or Constrained with upper bound >= 64K*/
+      enclen = encodeUnconsLength (pctxt, value);
+   }
+
+   return enclen;
+
+}
+
+int encodeObjectIdentifier (OOCTXT* pctxt, ASN1OBJID* pvalue)
+{
+   int len, stat;
+   ASN1UINT temp;
+   register int numids, i;
+
+   /* Calculate length in bytes and encode */
+
+   len = 1;  /* 1st 2 arcs require 1 byte */
+   numids = pvalue->numids;
+   for (i = 2; i < numids; i++) {
+      len += getIdentByteCount (pvalue->subid[i]);
+   }
+
+   /* PER encode length */
+
+   if ((stat = encodeLength (pctxt, (ASN1UINT)len)) < 0) {
+      return LOG_ASN1ERR (pctxt, stat);
+   }
+
+   /* Validate given object ID by applying ASN.1 rules */
+
+   if (0 == pvalue) return LOG_ASN1ERR (pctxt, ASN_E_INVOBJID);
+   if (numids < 2) return LOG_ASN1ERR (pctxt, ASN_E_INVOBJID);
+   if (pvalue->subid[0] > 2) return LOG_ASN1ERR (pctxt, ASN_E_INVOBJID);
+   if (pvalue->subid[0] != 2 && pvalue->subid[1] > 39) 
+      return LOG_ASN1ERR (pctxt, ASN_E_INVOBJID);
+
+   /* Passed checks, encode object identifier */
+   
+   /* Munge first two sub ID's and encode */
+
+   temp = ((pvalue->subid[0] * 40) + pvalue->subid[1]);
+   if ((stat = encodeIdent (pctxt, temp)) != ASN_OK)
+      return LOG_ASN1ERR (pctxt, stat);
+
+   /* Encode the remainder of the OID value */
+
+   for (i = 2; i < numids; i++) {
+      if ((stat = encodeIdent (pctxt, pvalue->subid[i])) != ASN_OK)
+         return LOG_ASN1ERR (pctxt, stat);
+   }
+
+   return ASN_OK;
+}
+
+int encodebitsFromOctet (OOCTXT* pctxt, ASN1OCTET value, ASN1UINT nbits)
+{ 
+   int lshift = pctxt->buffer.bitOffset;
+   int rshift = 8 - pctxt->buffer.bitOffset;
+   int stat = ASN_OK;
+   ASN1OCTET mask;
+
+   if (nbits == 0) return ASN_OK;
+
+   /* Mask off unused bits from the end of the value */
+
+   if (nbits < 8) {
+      switch (nbits) {
+      case 1: mask = 0x80; break;
+      case 2: mask = 0xC0; break;
+      case 3: mask = 0xE0; break;
+      case 4: mask = 0xF0; break;
+      case 5: mask = 0xF8; break;
+      case 6: mask = 0xFC; break;
+      case 7: mask = 0xFE; break;
+      default:;
+      }
+      value &= mask;
+   }
+
+   /* If we are on a byte boundary, we can do a direct assignment */
+
+   if (pctxt->buffer.bitOffset == 8) {
+      pctxt->buffer.data[pctxt->buffer.byteIndex] = value;
+      if (nbits == 8) {
+         pctxt->buffer.byteIndex++;
+         pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+      }
+      else
+         pctxt->buffer.bitOffset -= nbits;
+   }
+
+   /* Otherwise, need to set some bits in the first octet and   */
+   /* possibly some bits in the following octet..               */
+
+   else {
+      pctxt->buffer.data[pctxt->buffer.byteIndex] |= 
+         (ASN1OCTET)(value >> rshift);
+
+      pctxt->buffer.bitOffset -= nbits;
+
+      if (pctxt->buffer.bitOffset < 0) {
+         pctxt->buffer.byteIndex++;
+         pctxt->buffer.data[pctxt->buffer.byteIndex] = 
+            (ASN1OCTET)(value << lshift);
+         pctxt->buffer.bitOffset += 8;
+      }
+   }
+
+   return stat;
+}
+
+int encodeOctets (OOCTXT* pctxt, const ASN1OCTET* pvalue, ASN1UINT nbits)
+{ 
+   int i = 0, stat;
+   int numFullOcts = nbits / 8;
+
+   if (nbits == 0) return 0;
+
+   /* Check buffer space and allocate more memory if necessary */
+
+   stat = encodeCheckBuffer (pctxt, numFullOcts + 1);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   if (numFullOcts > 0) {
+
+      /* If the current bit offset is 8 (i.e. we don't have a      */
+      /* byte started), can copy the string directly to the        */
+      /* encode buffer..                                           */
+
+      if (pctxt->buffer.bitOffset == 8) {
+         memcpy (&pctxt->buffer.data[pctxt->buffer.byteIndex], pvalue, 
+                 numFullOcts);
+         pctxt->buffer.byteIndex += numFullOcts;
+         pctxt->buffer.data[pctxt->buffer.byteIndex] = 0;
+         i = numFullOcts;
+      }
+
+      /* Else, copy bits */
+
+      else {
+         for (i = 0; i < numFullOcts; i++) {
+            stat = encodeBitsFromOctet (pctxt, pvalue[i], 8);
+            if (stat != ASN_OK) return stat;
+         }
+      }
+   }
+
+   /* Move remaining bits from the last octet to the output buffer */
+
+   if (nbits % 8 != 0) {
+      stat = encodeBitsFromOctet (pctxt, pvalue[i], nbits % 8);
+   }
+
+   return stat;
+}
+
+int encodeOctetString (OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data)
+{
+   int enclen, octidx = 0, stat;
+   Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint;
+
+   for (;;) {
+      if ((enclen = encodeLength (pctxt, numocts)) < 0) {
+         return LOG_ASN1ERR (pctxt, enclen);
+      }
+
+      if (enclen > 0) {
+         ASN1BOOL doAlign;
+
+         stat = bitAndOctetStringAlignmentTest 
+            (pSizeList, numocts, FALSE, &doAlign);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         if (doAlign) {
+            stat = encodeByteAlign (pctxt);
+            if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+         }
+
+         stat = encodeOctets (pctxt, &data[octidx], enclen * 8);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+      }
+
+      if (enclen < (int)numocts) {
+         numocts -= enclen;
+         octidx += enclen;
+      }
+      else break;
+   }
+
+   return ASN_OK;
+}
+
+int encodeOpenType (OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data)
+{
+   int enclen, octidx = 0, stat;
+   ASN1OCTET zeroByte = 0x00;
+   ASN1OpenType openType;
+
+   /* If open type contains length zero, add a single zero byte (10.1) */
+
+   if (numocts == 0) {
+      openType.numocts = 1;
+      openType.data = &zeroByte;
+   }
+   else {
+      openType.numocts = numocts;
+      openType.data = data;
+   }
+
+   /* Encode the open type */
+
+   for (;;) {
+      if ((enclen = encodeLength (pctxt, openType.numocts)) < 0) {
+         return LOG_ASN1ERR (pctxt, enclen);
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      stat = encodeOctets (pctxt, &openType.data[octidx], enclen * 8);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+      if (enclen < (int)openType.numocts) {
+         openType.numocts -= enclen;
+         octidx += enclen;
+      }
+      else break;
+   }
+
+   return ASN_OK;
+}
+
+int encodeOpenTypeExt (OOCTXT* pctxt, DList* pElemList)
+{
+   DListNode* pnode;
+   ASN1OpenType* pOpenType;
+   int stat;
+
+   if (0 != pElemList) {
+      pnode = pElemList->head;
+      while (0 != pnode) {
+         if (0 != pnode->data) {
+            pOpenType = (ASN1OpenType*)pnode->data;
+
+            if (pOpenType->numocts > 0) {
+               stat = encodeByteAlign (pctxt);
+               if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+               stat = encodeOpenType 
+                  (pctxt, pOpenType->numocts, pOpenType->data);
+
+               if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+            }
+         }
+         pnode = pnode->next;
+      }
+   }
+
+   return ASN_OK;
+}
+
+int encodeOpenTypeExtBits (OOCTXT* pctxt, DList* pElemList)
+{
+   DListNode* pnode;
+   int stat;
+
+   if (0 != pElemList) {
+      pnode = pElemList->head;
+
+      while (0 != pnode) {
+         stat = encodeBit (pctxt, (ASN1BOOL)(0 != pnode->data));
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+         pnode = pnode->next;
+      }
+   }
+
+   return ASN_OK;
+}
+
+int encodeSemiConsInteger (OOCTXT* pctxt, ASN1INT value, ASN1INT lower)
+{
+   int nbytes, stat;
+   int shift = ((sizeof(value) - 1) * 8) - 1;
+   ASN1UINT tempValue;
+
+   if (lower > ASN1INT_MIN)
+      value -= lower;
+   
+   /* Calculate signed number value length */
+
+   for ( ; shift > 0; shift -= 8) {
+      tempValue = (value >> shift) & 0x1ff;
+      if (tempValue == 0 || tempValue == 0x1ff) continue;
+      else break;
+   }
+
+   nbytes = (shift + 9) / 8;
+
+   /* Encode length */
+
+   if ((stat = encodeLength (pctxt, nbytes)) < 0) {
+      return stat;
+   }
+
+   if ((stat = encodeByteAlign (pctxt)) != ASN_OK)
+      return stat;
+
+   /* Encode signed value */
+
+   stat = encode2sCompBinInt (pctxt, value);
+
+   return stat;
+}
+
+int encodeSemiConsUnsigned (OOCTXT* pctxt, ASN1UINT value, ASN1UINT lower)
+{
+   int nbytes, stat;
+   int shift = ((sizeof(value) - 1) * 8) - 1;
+   ASN1UINT mask = 1UL << ((sizeof(value) * 8) - 1);
+   ASN1UINT tempValue;
+
+   value -= lower;
+
+   /* Calculate unsigned number value length */
+
+   for ( ; shift > 0; shift -= 8) {
+      tempValue = (value >> shift) & 0x1ff;
+
+      if (tempValue == 0) continue;
+      else break;
+   }
+
+   nbytes = (shift + 9) / 8;
+
+   /* If MS bit in unsigned number is set, add an extra zero byte */
+
+   if ((value & mask) != 0) nbytes++;
+
+   /* Encode length */
+
+   if ((stat = encodeLength (pctxt, nbytes)) < 0) {
+      return stat;
+   }
+   
+   if ((stat = encodeByteAlign (pctxt)) != ASN_OK)
+      return stat;
+   
+   /* Encode additional zero byte if necessary */
+
+   if (nbytes > sizeof(value)) {
+      stat = encodebitsFromOctet (pctxt, 0, 8);
+      if (stat != ASN_OK) return (stat);
+   }
+
+   /* Encode unsigned value */
+
+   stat = encodeNonNegBinInt (pctxt, value);
+
+   return stat;
+}
+
+int encodeSmallNonNegWholeNumber (OOCTXT* pctxt, ASN1UINT value)
+{ 
+   int stat;
+
+   if (value < 64) {
+      stat = encodeBits (pctxt, value, 7);
+   }
+   else {
+      ASN1UINT len;
+
+      /* Encode a one-byte length determinant value */
+      if (value < 256) len = 1;
+      else if (value < 65536) len = 2;
+      else if (value < 0x1000000) len = 3;
+      else len = 4;
+
+      stat = encodeBits (pctxt, len, 8);
+
+      /* Byte-align and encode the value */
+      if (stat == ASN_OK) {
+         if ((stat = encodeByteAlign (pctxt)) == ASN_OK) {
+            stat = encodeBits (pctxt, value, len*8);
+         }
+      }
+   }
+
+   return stat;
+}
+
+int encodeVarWidthCharString (OOCTXT* pctxt, const char* value)
+{
+   int         stat;
+   ASN1UINT    len = strlen (value);
+   /* note: need to save size constraint for use in alignCharStr     */
+   /* because it will be cleared in encodeLength from the context..        */
+   Asn1SizeCnst* psize = pctxt->pSizeConstraint;
+
+   /* Encode length */
+
+   stat = encodeLength (pctxt, len);
+   if (stat < 0) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Byte align */
+
+   if (alignCharStr (pctxt, len, 8, psize)) {
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+   }
+
+   /* Encode data */
+
+   stat = encodeOctets (pctxt, (const ASN1OCTET*)value, len * 8);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   return ASN_OK;
+}
+
+static int encode16BitConstrainedString 
+(OOCTXT* pctxt, Asn116BitCharString value, Asn116BitCharSet* pCharSet)
+{
+   ASN1UINT i, pos;
+   ASN1UINT nbits = pCharSet->alignedBits;
+   int stat;
+
+   /* Encode length */
+
+   stat = encodeLength (pctxt, value.nchars);
+   if (stat < 0) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Byte align */
+
+   stat = encodeByteAlign (pctxt);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   /* Encode data */
+
+   for (i = 0; i < value.nchars; i++) {
+      if (pCharSet->charSet.data == 0) {
+         stat = encodeBits 
+            (pctxt, value.data[i] - pCharSet->firstChar, nbits);
+         if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+      }
+      else {
+         for (pos = 0; pos < pCharSet->charSet.nchars; pos++) {
+            if (value.data[i] == pCharSet->charSet.data[pos]) {
+               stat = encodeBits (pctxt, pos, nbits);
+               if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+               break;
+            }
+         }
+      }
+   }
+
+   return stat;
+}
+
+int encode2sCompBinInt (OOCTXT* pctxt, ASN1INT value)
+{
+   /* 10.4.6  A minimum octet 2's-complement-binary-integer encoding    */
+   /* of the whole number has a field width that is a multiple of 8     */
+   /* bits and also satisifies the condition that the leading 9 bits    */
+   /* field shall not be all zeros and shall not be all ones.           */
+
+   /* first encode integer value into a local buffer */
+
+   ASN1OCTET lbuf[8], lb;
+   ASN1INT   i = sizeof(lbuf), temp = value;
+
+   memset (lbuf, 0, sizeof(lbuf));
+   do {
+      lb = temp % 256;
+      temp /= 256;
+      if (temp < 0 && lb != 0) temp--; /* two's complement adjustment */
+      lbuf[--i] = lb;
+   } while (temp != 0 && temp != -1);
+
+   /* If the value is positive and bit 8 of the leading byte is set,    */
+   /* copy a zero byte to the contents to signal a positive number..    */
+
+   if (value > 0 && (lb & 0x80) != 0) {
+      i--;
+   }
+
+   /* If the value is negative and bit 8 of the leading byte is clear,  */
+   /* copy a -1 byte (0xFF) to the contents to signal a negative        */
+   /* number..                                                          */
+
+   else if (value < 0 && ((lb & 0x80) == 0)) {
+      lbuf[--i] = 0xff;
+   }
+
+   /* Add the data to the encode buffer */
+
+   return encodeOctets (pctxt, &lbuf[i], (sizeof(lbuf) - i) * 8);
+}
+
+static int encodeNonNegBinInt (OOCTXT* pctxt, ASN1UINT value)
+{
+   /* 10.3.6  A minimum octet non-negative binary integer encoding of   */
+   /* the whole number (which does not predetermine the number of       */
+   /* octets to be used for the encoding) has a field which is a        */
+   /* multiple of 8 bits and also satisifies the condition that the     */
+   /* leading eight bits of the field shall not be zero unless the      */
+   /* field is precisely 8 bits long.                                   */
+ 
+   ASN1UINT bitcnt = (value == 0) ? 1 : getUIntBitCount (value);
+
+   /* round-up to nearest 8-bit boundary */
+
+   bitcnt = (bitcnt + 7) & (~7);
+
+   /* encode bits */
+
+   return encodeBits (pctxt, value, bitcnt);
+}
+
+static int encodeUnconsLength (OOCTXT* pctxt, ASN1UINT value)
+{
+   int enclen, stat;
+
+   stat = encodeByteAlign (pctxt);
+   if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+
+   /* 1 octet case */
+   if (value < 128) {
+      stat = encodeBits (pctxt, value, 8);
+      enclen = (stat == ASN_OK) ? value : stat;
+   }
+   /* 2 octet case */
+   else if (value < 16384) {
+      if ((stat = encodeBit (pctxt, 1)) == ASN_OK)
+         stat = encodeBits (pctxt, value, 15);
+      enclen = (stat == ASN_OK) ? value : stat;
+   }
+   /* fragmentation case */
+   else {
+      int multiplier = ASN1MIN (value/16384, 4);
+      encodeBit (pctxt, 1);  /* set bit 8 of first octet */
+      encodeBit (pctxt, 1);  /* set bit 7 of first octet */
+      stat = encodeBits (pctxt, multiplier, 6);
+      enclen = (stat == ASN_OK) ? 16384 * multiplier : stat;
+   }
+
+   return enclen;
+}
+
+static int getIdentByteCount (ASN1UINT ident) 
+{
+   if (ident < (1u << 7)) {         /* 7 */
+      return 1;
+   }
+   else if (ident < (1u << 14)) {   /* 14 */
+      return 2;
+   }
+   else if (ident < (1u << 21)) {   /* 21 */
+      return 3;
+   }
+   else if (ident < (1u << 28)) {   /* 28 */
+      return 4;
+   }
+   return 5;
+}
diff --git a/addons/ooh323c/src/errmgmt.c b/addons/ooh323c/src/errmgmt.c
new file mode 100644
index 000000000..d41bad102
--- /dev/null
+++ b/addons/ooh323c/src/errmgmt.c
@@ -0,0 +1,261 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/* Error management functions */
+
+#include <stdlib.h>
+#include "ooasn1.h"
+
+/* Error status text */
+static const char* g_status_text[] = {
+    "Encode buffer overflow",
+    "Unexpected end of buffer on decode",
+    "Unexpected tag encountered: expected = %s, parsed = %s",
+    "Invalid object identifier",
+    "Invalid field length detected",
+    "Enumerated value %s not in defined set",
+    "Duplicate element in SET",
+    "Missing required element in SET",
+    "Element with tag %s not part of SET",
+    "Max elements defined for SEQUENCE field exceeded",
+    "Element with tag %s is an invalid option in choice",
+    "No dynamic memory available",
+    "Invalid string type",
+    "Invalid hex string",
+    "Invalid binary string",
+    "Invalid real value",
+    "Max items in sized BIT or OCTET STRING field exceeded",
+    "Invalid value specification",
+    "No definition found for referenced defined value",
+    "No definition found for referenced defined type",
+    "Invalid tag value",
+    "Nesting level too deep",
+    "Value constraint violation: field %s, value %s",
+    "Value range error: lower bound is greater than upper",
+    "Unexpected end of file detected",
+    "Invalid UTF-8 character at index %d", 
+    "List error: concurrent modification attempt while iterating", 
+    "List error: illegal state for attempted operation",
+    "Array index out of bounds",
+    "Invalid parameter passed to function or method",
+    "Invalid time string format",
+    "Context is not initialized", 
+    "ASN.1 value will not fit in target variable", 
+    "Character is not within the defined character set", 
+    "Invalid XML state for attempted operation", 
+    "Error condition returned from XML parser:\n%s", 
+    "SEQUENCE elements not in correct order",
+    "Invalid index for table constraint identifier",
+    "Invalid value for relational table constraint fixed type field", 
+    "File not found", 
+    "File read error",
+    "File write error",
+    "Invalid Base64 string",
+    "Socket error",
+    "XML interface library not found",
+    "Invalid XML interface library"
+} ;
+
+#define ASN1_K_MAX_STAT (sizeof(g_status_text)/sizeof(char *))
+
+/* Add an integer parameter to an error message */
+
+int errAddIntParm (ASN1ErrInfo* pErrInfo, int errParm)
+{
+   char lbuf[16];
+   sprintf (lbuf, "%d", errParm);
+   return errAddStrParm (pErrInfo, lbuf);
+}
+
+/* Add a character string parameter to an error message */
+
+int errAddStrParm (ASN1ErrInfo* pErrInfo, const char* errprm_p)
+{
+#if defined(_NO_THREADS) || !defined(_NO_MALLOC)
+   if (pErrInfo->parmcnt < ASN_K_MAXERRP) {
+      char* tmpstr = (char*) ASN1CRTMALLOC0 (strlen(errprm_p)+1);
+      strcpy (tmpstr, errprm_p);
+      pErrInfo->parms[pErrInfo->parmcnt] = tmpstr;
+      pErrInfo->parmcnt++;
+      return TRUE;
+   }
+   else
+#endif
+      return FALSE;
+}
+
+/* Add an unsigned integer parameter to an error message */
+
+int errAddUIntParm (ASN1ErrInfo* pErrInfo, unsigned int errParm)
+{
+   char lbuf[16];
+   sprintf (lbuf, "%u", errParm);
+   return errAddStrParm (pErrInfo, lbuf);
+}
+
+/* Free error parameter memory */
+
+void errFreeParms (ASN1ErrInfo* pErrInfo)
+{
+#if defined(_NO_THREADS) || !defined(_NO_MALLOC)
+   int i;
+
+   for (i = 0; i < pErrInfo->parmcnt; i++)
+      ASN1CRTFREE0 ((char*)pErrInfo->parms[i]);
+#endif
+
+   pErrInfo->parmcnt = 0;
+   pErrInfo->status = 0;
+}
+
+/* Reset error */
+
+int errReset (ASN1ErrInfo* pErrInfo)
+{
+   errFreeParms (pErrInfo);
+   pErrInfo->stkx = 0;
+   return ASN_OK;
+}
+
+/* Format error message */
+
+char* errFmtMsg (ASN1ErrInfo* pErrInfo, char* bufp)
+{
+   const char* tp;
+   int  i, j, pcnt;
+
+   if (pErrInfo->status < 0)
+   {
+      i = abs (pErrInfo->status + 1);
+
+      if (i >= 0 && i < ASN1_K_MAX_STAT)
+      {
+         /* Substitute error parameters into error message */
+
+         j  = pcnt = 0;
+         tp = g_status_text[i];
+
+         while (*tp) 
+         {
+            if (*tp == '%' && *(tp+1) == 's')
+            {
+               /* Plug in error parameter */
+
+               if (pcnt < pErrInfo->parmcnt && pErrInfo->parms[pcnt])
+               {
+                  strcpy (&bufp[j], pErrInfo->parms[pcnt]);
+                  j += strlen (pErrInfo->parms[pcnt++]);
+               }
+               else
+                  bufp[j++] = '?';
+
+               tp += 2;
+            }
+            else
+               bufp[j++] = *tp++;
+         }
+
+         bufp[j] = '\0';        /* null terminate string */
+      }
+      else
+         strcpy (bufp, "unrecognized completion status");
+   }    
+   else strcpy (bufp, "normal completion status");
+
+   return (bufp);
+}
+
+/* Get error text in a dynamic memory buffer.  This allocates memory    */
+/* using the 'memAlloc' function.  This memory is automatically freed */ 
+/* at the time the 'memFree' function is called.                      */
+
+char* errGetText (OOCTXT* pctxt)
+{
+   char lbuf[500];
+   char* pBuf = (char*) ASN1MALLOC (pctxt,
+      (sizeof(lbuf) + 100 * (2 + pctxt->errInfo.stkx)) * sizeof(char));
+
+   sprintf (pBuf, "ASN.1 ERROR: Status %d\n", pctxt->errInfo.status);
+   sprintf (lbuf, "%s\nStack trace:", errFmtMsg (&pctxt->errInfo, lbuf));
+   strcat(pBuf, lbuf);
+
+   while (pctxt->errInfo.stkx > 0) {
+      pctxt->errInfo.stkx--;
+      sprintf (lbuf, "  Module: %s, Line %d\n", 
+               pctxt->errInfo.stack[pctxt->errInfo.stkx].module,
+               pctxt->errInfo.stack[pctxt->errInfo.stkx].lineno);
+      strcat(pBuf, lbuf);
+   }
+
+   errFreeParms (&pctxt->errInfo);
+
+   return pBuf;
+}
+
+/* Print error information to the standard output */
+
+void errPrint (ASN1ErrInfo* pErrInfo)
+{
+   char lbuf[200];
+   printf ("ASN.1 ERROR: Status %d\n", pErrInfo->status);
+   printf ("%s\n", errFmtMsg (pErrInfo, lbuf));
+   printf ("Stack trace:");
+   while (pErrInfo->stkx > 0) {
+      pErrInfo->stkx--;
+      printf ("  Module: %s, Line %d\n", 
+              pErrInfo->stack[pErrInfo->stkx].module,
+              pErrInfo->stack[pErrInfo->stkx].lineno);
+   }
+   errFreeParms (pErrInfo);
+}
+
+/* Copy error data from one error structure to another */
+
+int errCopyData (ASN1ErrInfo* pSrcErrInfo, ASN1ErrInfo* pDestErrInfo)
+{
+   int i;
+   pDestErrInfo->status = pSrcErrInfo->status;
+
+   /* copy error parameters */
+
+   for (i = 0; i < pSrcErrInfo->parmcnt; i++) {
+      errAddStrParm (pDestErrInfo, pSrcErrInfo->parms[i]);
+   }
+
+   /* copy stack info */
+
+   for (i = 0; i < pSrcErrInfo->stkx; i++) {
+      if (pDestErrInfo->stkx < ASN_K_MAXERRSTK) {
+         pDestErrInfo->stack[pDestErrInfo->stkx].module = 
+            pSrcErrInfo->stack[i].module;
+         pDestErrInfo->stack[pDestErrInfo->stkx++].lineno = 
+            pSrcErrInfo->stack[i].lineno;
+      }
+   }
+
+   return (pSrcErrInfo->status);
+}
+
+
+int errSetData (ASN1ErrInfo* pErrInfo, int status, 
+                  const char* module, int lno) 
+{ 
+   if (pErrInfo->status == 0) {
+      pErrInfo->status = status;
+   }
+   ooLogAsn1Error(status, module, lno);
+   return status; 
+}
diff --git a/addons/ooh323c/src/eventHandler.c b/addons/ooh323c/src/eventHandler.c
new file mode 100644
index 000000000..7b15759a6
--- /dev/null
+++ b/addons/ooh323c/src/eventHandler.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "eventHandler.h"
+
+void setEventHandler (OOCTXT* pctxt, EventHandler* pHandler)
+{
+   pctxt->pEventHandler = pHandler;
+}
+
+void removeEventHandler (OOCTXT* pctxt)
+{
+   pctxt->pEventHandler = 0;
+}
+
+void invokeStartElement (OOCTXT* pctxt, const char* name, int index)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->startElement (name, index);
+   }
+}
+
+void invokeEndElement (OOCTXT* pctxt, const char* name, int index)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->endElement (name, index);
+   }
+}
+
+void invokeBoolValue (OOCTXT* pctxt, ASN1BOOL value)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->boolValue (value);
+   }
+}
+
+void invokeIntValue (OOCTXT* pctxt, ASN1INT value)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->intValue (value);
+   }
+}
+
+void invokeUIntValue (OOCTXT* pctxt, ASN1UINT value)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->uIntValue (value);
+   }
+}
+
+void invokeBitStrValue (OOCTXT* pctxt, ASN1UINT numbits, 
+                        const ASN1OCTET* data)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->bitStrValue (numbits, data);
+   }
+}
+
+void invokeOctStrValue (OOCTXT* pctxt, ASN1UINT numocts, 
+                        const ASN1OCTET* data)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->octStrValue (numocts, data);
+   }
+}
+
+void invokeCharStrValue (OOCTXT* pctxt, const char* value)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->charStrValue (value);
+   }
+}
+
+void invokeCharStr16BitValue (OOCTXT* pctxt, ASN1UINT nchars, 
+                              ASN116BITCHAR* data)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->charStr16BitValue (nchars, data);
+   }
+}
+
+void invokeNullValue (OOCTXT* pctxt)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->nullValue ();
+   }
+}
+
+void invokeOidValue (OOCTXT* pctxt, ASN1UINT numSubIds, ASN1UINT* pSubIds)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->oidValue (numSubIds, pSubIds);
+   }
+}
+
+void invokeEnumValue (OOCTXT* pctxt, ASN1UINT value)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->enumValue (value);
+   }
+}
+
+void invokeOpenTypeValue (OOCTXT* pctxt, ASN1UINT numocts, 
+                          const ASN1OCTET* data)
+{
+   if (0 != pctxt->pEventHandler) {
+      pctxt->pEventHandler->openTypeValue (numocts, data);
+   }
+}
diff --git a/addons/ooh323c/src/eventHandler.h b/addons/ooh323c/src/eventHandler.h
new file mode 100644
index 000000000..320a55b99
--- /dev/null
+++ b/addons/ooh323c/src/eventHandler.h
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file eventHandler.h 
+ * C event handler structure.  This structure holds event handler function 
+ * callbacks for use by the generated code.
+ */
+/**
+ * @defgroup EventHandler event handler
+ * Event handler structures and callback function definitions.
+ * @{
+ */
+#ifndef _EVENTHANDLER_H_
+#define _EVENTHANDLER_H_
+
+#include <stdio.h>
+#include "ooasn1.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef EXTERN
+#if define (MAKE_DLL)
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+
+/**
+ * This is a function pointer for a callback function which is invoked 
+ * from within a decode function when an element of a SEQUENCE, SET, 
+ * SEQUENCE OF, SET OF, or CHOICE construct is parsed.
+ *
+ * @param name         For SEQUENCE, SET, or CHOICE, this is the name of the
+ *                       element as defined in the ASN.1 defination. For
+ *                       SEQUENCE OF or SET OF, this is set to the name
+ *                       "element".
+ * @param index        For SEQUENCE, SET, or CHOICE, this is not used and is
+ *                       set to the value
+ *                       -1. For SEQUENCE OF or SET OF, this contains the
+ *                       zero-based index of the element in the conceptual
+ *                       array associated with the construct.
+ * @return             - none
+ */
+typedef void (*StartElement) (const char* name, int index) ;
+
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when parsing is complete on an element of a 
+ * SEQUENCE, SET, SEQUENCE OF, SET OF, or CHOICE construct.
+ *
+ * @param name         For SEQUENCE, SET, or CHOICE, this is the name of the
+ *                       element as defined in the ASN.1 defination. For
+ *                       SEQUENCE OF or SET OF, this is set to the name
+ *                       "element".
+ * @param index        For SEQUENCE, SET, or CHOICE, this is not used and is
+ *                       set to the value
+ *                       -1. For SEQUENCE OF or SET OF, this contains the
+ *                       zero-based index of the element in the conceptual
+ *                       array associated with the construct.
+ * @return             - none
+ */
+typedef void (*EndElement) (const char* name, int index) ;
+
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when a value of the BOOLEAN ASN.1 type is parsed.
+ *
+ * @param value        Parsed value.
+ * @return             - none
+ */
+typedef void (*BoolValue) (ASN1BOOL value);
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when a value of the INTERGER ASN.1 type is parsed.
+ *
+ * @param value        Parsed value.
+ * @return             - none
+ */
+typedef void (*IntValue) (ASN1INT value);
+
+/**
+ * This is a function pointer for a callback function which is invoked 
+ * from within a decode function when a value of the INTEGER ASN.1 type 
+ * is parsed. In this case, constraints on the integer value forced the 
+ * use of unsigned integer C type to represent the value.
+ *
+ * @param value        Parsed value.
+ * @return             - none
+ */
+typedef void (*UIntValue) (ASN1UINT value);
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when a value of the BIT STRING ASN.1 type is 
+ * parsed.
+ *
+ * @param numbits      - Number of bits in the parsed value. 
+ * @param data         - Pointer to a byte array that contains the bit 
+ *                         string data.
+ * @return             - none
+ */ 
+typedef void (*BitStrValue) (ASN1UINT numbits, const ASN1OCTET* data);
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when a value of one of the OCTET STRING ASN.1 type
+ * is parsed.
+ *
+ * @param numocts      Number of octets in the parsed value.
+ * @param data         Pointer to byte array containing the octet string
+ *                       data.
+ * @return             - none
+ */
+typedef void (*OctStrValue) (ASN1UINT numocts, const ASN1OCTET* data) ;
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when a value of one of the 8-bit ASN.1 character 
+ * string types is parsed.
+ *
+ * @param value        Null terminated character string value.
+ * @return             - none
+ */
+typedef void (*CharStrValue) (const char* value) ;
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when a value of one of the 16-bit ASN.1 character 
+ * string types is parsed.
+ *
+ * This is used for the ASN.1 BmpString type.
+ *
+ * @param nchars       Number of characters in the parsed value.
+ * @param data         Pointer to an array containing 16-bit values.
+ *                       These are represented using unsigned short integer
+ *                       values.
+ * @return             - none
+ */
+typedef void (*CharStrValue16Bit) (ASN1UINT nchars, ASN116BITCHAR* data) ;
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when a value of the NULL ASN.1 type is parsed.
+ *
+ * @param             - none
+ * @return             - none
+ */
+typedef void (*NullValue) () ;
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function whn a value the OBJECT IDENTIFIER ASN.1 type is 
+ * parsed.
+ *
+ * @param numSubIds    Number of subidentifiers in the object identifier.
+ * @param pSubIds      Pointer to array containing the subidentifier values.
+ * @return             -none
+ */
+typedef void (*OidValue) (ASN1UINT numSubIds, ASN1UINT* pSubIds) ;
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when a value of the ENUMERATED ASN.1 type is 
+ * parsed.
+ *
+ * @param value        - Parsed enumerated value
+ * @return             - none
+ */
+typedef void (*EnumValue) (ASN1UINT value) ;
+
+/**
+ * This is a function pointer for a callback function which is invoked from 
+ * within a decode function when an ASN.1 open type is parsed.
+ *
+ * @param numocts      Number of octets in the parsed value.
+ * @param data         Pointer to byet array contain in tencoded ASN.1
+ *                       value.
+ * @return             - none
+ */
+typedef void (*OpenTypeValue) (ASN1UINT numocts, const ASN1OCTET* data) ;
+
+
+/**
+ * This is a basic C based event handler structure, which can be used
+ * to define user-defined event handlers.
+ */
+typedef struct EventHandler {
+   StartElement      startElement;
+   EndElement        endElement;
+   BoolValue         boolValue;
+   IntValue          intValue;
+   UIntValue         uIntValue;
+   BitStrValue       bitStrValue;
+   OctStrValue       octStrValue;
+   CharStrValue      charStrValue;
+   CharStrValue16Bit charStr16BitValue;
+   NullValue         nullValue;
+   OidValue          oidValue;
+   EnumValue         enumValue;
+   OpenTypeValue     openTypeValue;
+} EventHandler;
+
+
+/**
+ * This function sets the event handler object within the context.  It 
+ * will overwrite the definition of any handler that was set previously.
+ *
+ * @param pctxt       Context to which event handler has to be added.
+ * @param pHandler    Pointer to the event handler structure.
+ * @return            none
+ */
+EXTERN void setEventHandler (OOCTXT* pctxt, EventHandler* pHandler);
+
+/**
+ * This function is called to remove the event handler current defined 
+ * in the context.  This is done by setting the event handler object 
+ * pointer to NULL.
+ *
+ * @param pctxt       Context from which event handler has to be removed.
+ * @return            none
+ */
+EXTERN void removeEventHandler (OOCTXT* pctxt);
+
+/**
+ * The following functions are invoked from within the generated 
+ * code to call the various user-defined event handler methods ..
+ */
+EXTERN void invokeStartElement (OOCTXT* pctxt, const char* name, int index);
+EXTERN void invokeEndElement (OOCTXT* pctxt, const char* name, int index);
+EXTERN void invokeBoolValue (OOCTXT* pctxt, ASN1BOOL value);
+EXTERN void invokeIntValue (OOCTXT* pctxt, ASN1INT value);
+EXTERN void invokeUIntValue (OOCTXT* pctxt, ASN1UINT value);
+
+EXTERN void invokeBitStrValue 
+(OOCTXT* pctxt, ASN1UINT numbits, const ASN1OCTET* data);
+
+EXTERN void invokeOctStrValue 
+(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data);
+
+EXTERN void invokeCharStrValue (OOCTXT* pctxt, const char* value);
+
+EXTERN void invokeCharStr16BitValue 
+(OOCTXT* pctxt, ASN1UINT nchars, ASN116BITCHAR* data);
+
+EXTERN void invokeNullValue (OOCTXT* pctxt);
+
+EXTERN void invokeOidValue 
+(OOCTXT* pctxt, ASN1UINT numSubIds, ASN1UINT* pSubIds);
+
+EXTERN void invokeEnumValue (OOCTXT* pctxt, ASN1UINT value);
+
+EXTERN void invokeOpenTypeValue 
+(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data);
+
+/** 
+ * @} 
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif 
diff --git a/addons/ooh323c/src/h323/H235-SECURITY-MESSAGES.h b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGES.h
new file mode 100644
index 000000000..2f401b39a
--- /dev/null
+++ b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGES.h
@@ -0,0 +1,690 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#ifndef H235_SECURITY_MESSAGES_H
+#define H235_SECURITY_MESSAGES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ooasn1.h"
+
+/**************************************************************/
+/*                                                            */
+/*  ChallengeString                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ChallengeString {
+   ASN1UINT numocts;
+   ASN1OCTET data[128];
+} H235ChallengeString;
+
+EXTERN int asn1PE_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue);
+
+EXTERN int asn1PD_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TimeStamp                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT H235TimeStamp;
+
+EXTERN int asn1PE_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp value);
+
+EXTERN int asn1PD_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RandomVal                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1INT H235RandomVal;
+
+EXTERN int asn1PE_H235RandomVal (OOCTXT* pctxt, H235RandomVal value);
+
+EXTERN int asn1PD_H235RandomVal (OOCTXT* pctxt, H235RandomVal* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Password                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1BMPString H235Password;
+
+EXTERN int asn1PE_H235Password (OOCTXT* pctxt, H235Password value);
+
+EXTERN int asn1PD_H235Password (OOCTXT* pctxt, H235Password* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedPwdCertToken                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1OpenType H235EncodedPwdCertToken;
+
+EXTERN int asn1PE_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken value);
+
+EXTERN int asn1PD_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235NonStandardParameter {
+   ASN1OBJID nonStandardIdentifier;
+   ASN1DynOctStr data;
+} H235NonStandardParameter;
+
+EXTERN int asn1PE_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue);
+
+EXTERN int asn1PD_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationBES                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H235AuthenticationBES_default_ 1
+#define T_H235AuthenticationBES_radius  2
+#define T_H235AuthenticationBES_extElem1 3
+
+typedef struct EXTERN H235AuthenticationBES {
+   int t;
+} H235AuthenticationBES;
+
+EXTERN int asn1PE_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue);
+
+EXTERN int asn1PD_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationMechanism                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H235AuthenticationMechanism_dhExch 1
+#define T_H235AuthenticationMechanism_pwdSymEnc 2
+#define T_H235AuthenticationMechanism_pwdHash 3
+#define T_H235AuthenticationMechanism_certSign 4
+#define T_H235AuthenticationMechanism_ipsec 5
+#define T_H235AuthenticationMechanism_tls 6
+#define T_H235AuthenticationMechanism_nonStandard 7
+#define T_H235AuthenticationMechanism_authenticationBES 8
+#define T_H235AuthenticationMechanism_extElem1 9
+
+typedef struct EXTERN H235AuthenticationMechanism {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      H235NonStandardParameter *nonStandard;
+      /* t = 8 */
+      H235AuthenticationBES *authenticationBES;
+      /* t = 9 */
+   } u;
+} H235AuthenticationMechanism;
+
+EXTERN int asn1PE_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue);
+
+EXTERN int asn1PD_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_halfkey                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235DHset_halfkey {
+   ASN1UINT  numbits;
+   ASN1OCTET data[256];
+} H235DHset_halfkey;
+
+EXTERN int asn1PE_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue);
+
+EXTERN int asn1PD_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_modSize                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235DHset_modSize {
+   ASN1UINT  numbits;
+   ASN1OCTET data[256];
+} H235DHset_modSize;
+
+EXTERN int asn1PE_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue);
+
+EXTERN int asn1PD_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_generator                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235DHset_generator {
+   ASN1UINT  numbits;
+   ASN1OCTET data[256];
+} H235DHset_generator;
+
+EXTERN int asn1PE_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue);
+
+EXTERN int asn1PD_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DHset                                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235DHset {
+   H235DHset_halfkey halfkey;
+   H235DHset_modSize modSize;
+   H235DHset_generator generator;
+} H235DHset;
+
+EXTERN int asn1PE_H235DHset (OOCTXT* pctxt, H235DHset* pvalue);
+
+EXTERN int asn1PD_H235DHset (OOCTXT* pctxt, H235DHset* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TypedCertificate                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235TypedCertificate {
+   ASN1OBJID type;
+   ASN1DynOctStr certificate;
+} H235TypedCertificate;
+
+EXTERN int asn1PE_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue);
+
+EXTERN int asn1PD_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Identifier                                                */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1BMPString H235Identifier;
+
+EXTERN int asn1PE_H235Identifier (OOCTXT* pctxt, H235Identifier value);
+
+EXTERN int asn1PD_H235Identifier (OOCTXT* pctxt, H235Identifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint_x                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECpoint_x {
+   ASN1UINT  numbits;
+   ASN1OCTET data[64];
+} H235ECpoint_x;
+
+EXTERN int asn1PE_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue);
+
+EXTERN int asn1PD_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint_y                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECpoint_y {
+   ASN1UINT  numbits;
+   ASN1OCTET data[64];
+} H235ECpoint_y;
+
+EXTERN int asn1PE_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue);
+
+EXTERN int asn1PD_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint                                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECpoint {
+   struct {
+      unsigned xPresent : 1;
+      unsigned yPresent : 1;
+   } m;
+   H235ECpoint_x x;
+   H235ECpoint_y y;
+} H235ECpoint;
+
+EXTERN int asn1PE_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue);
+
+EXTERN int asn1PD_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_modulus                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECKASDH_eckasdhp_modulus {
+   ASN1UINT  numbits;
+   ASN1OCTET data[64];
+} H235ECKASDH_eckasdhp_modulus;
+
+EXTERN int asn1PE_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_weierstrassA                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECKASDH_eckasdhp_weierstrassA {
+   ASN1UINT  numbits;
+   ASN1OCTET data[64];
+} H235ECKASDH_eckasdhp_weierstrassA;
+
+EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_weierstrassB                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECKASDH_eckasdhp_weierstrassB {
+   ASN1UINT  numbits;
+   ASN1OCTET data[64];
+} H235ECKASDH_eckasdhp_weierstrassB;
+
+EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECKASDH_eckasdhp {
+   H235ECpoint public_key;
+   H235ECKASDH_eckasdhp_modulus modulus;
+   H235ECpoint base;
+   H235ECKASDH_eckasdhp_weierstrassA weierstrassA;
+   H235ECKASDH_eckasdhp_weierstrassB weierstrassB;
+} H235ECKASDH_eckasdhp;
+
+EXTERN int asn1PE_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_fieldSize                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECKASDH_eckasdh2_fieldSize {
+   ASN1UINT  numbits;
+   ASN1OCTET data[64];
+} H235ECKASDH_eckasdh2_fieldSize;
+
+EXTERN int asn1PE_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_weierstrassA                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECKASDH_eckasdh2_weierstrassA {
+   ASN1UINT  numbits;
+   ASN1OCTET data[64];
+} H235ECKASDH_eckasdh2_weierstrassA;
+
+EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_weierstrassB                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECKASDH_eckasdh2_weierstrassB {
+   ASN1UINT  numbits;
+   ASN1OCTET data[64];
+} H235ECKASDH_eckasdh2_weierstrassB;
+
+EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ECKASDH_eckasdh2 {
+   H235ECpoint public_key;
+   H235ECKASDH_eckasdh2_fieldSize fieldSize;
+   H235ECpoint base;
+   H235ECKASDH_eckasdh2_weierstrassA weierstrassA;
+   H235ECKASDH_eckasdh2_weierstrassB weierstrassB;
+} H235ECKASDH_eckasdh2;
+
+EXTERN int asn1PE_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH                                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H235ECKASDH_eckasdhp          1
+#define T_H235ECKASDH_eckasdh2          2
+#define T_H235ECKASDH_extElem1          3
+
+typedef struct EXTERN H235ECKASDH {
+   int t;
+   union {
+      /* t = 1 */
+      H235ECKASDH_eckasdhp *eckasdhp;
+      /* t = 2 */
+      H235ECKASDH_eckasdh2 *eckasdh2;
+      /* t = 3 */
+   } u;
+} H235ECKASDH;
+
+EXTERN int asn1PE_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue);
+
+EXTERN int asn1PD_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ClearToken                                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ClearToken {
+   struct {
+      unsigned timeStampPresent : 1;
+      unsigned passwordPresent : 1;
+      unsigned dhkeyPresent : 1;
+      unsigned challengePresent : 1;
+      unsigned randomPresent : 1;
+      unsigned certificatePresent : 1;
+      unsigned generalIDPresent : 1;
+      unsigned nonStandardPresent : 1;
+      unsigned eckasdhkeyPresent : 1;
+      unsigned sendersIDPresent : 1;
+   } m;
+   ASN1OBJID tokenOID;
+   H235TimeStamp timeStamp;
+   H235Password password;
+   H235DHset dhkey;
+   H235ChallengeString challenge;
+   H235RandomVal random;
+   H235TypedCertificate certificate;
+   H235Identifier generalID;
+   H235NonStandardParameter nonStandard;
+   H235ECKASDH eckasdhkey;
+   H235Identifier sendersID;
+} H235ClearToken;
+
+EXTERN int asn1PE_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue);
+
+EXTERN int asn1PD_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IV8                                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235IV8 {
+   ASN1UINT numocts;
+   ASN1OCTET data[8];
+} H235IV8;
+
+EXTERN int asn1PE_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue);
+
+EXTERN int asn1PD_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IV16                                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235IV16 {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H235IV16;
+
+EXTERN int asn1PE_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue);
+
+EXTERN int asn1PD_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Params                                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235Params {
+   struct {
+      unsigned ranIntPresent : 1;
+      unsigned iv8Present : 1;
+      unsigned iv16Present : 1;
+   } m;
+   ASN1INT ranInt;
+   H235IV8 iv8;
+   H235IV16 iv16;
+} H235Params;
+
+EXTERN int asn1PE_H235Params (OOCTXT* pctxt, H235Params* pvalue);
+
+EXTERN int asn1PD_H235Params (OOCTXT* pctxt, H235Params* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ENCRYPTED                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235ENCRYPTED {
+   ASN1OBJID algorithmOID;
+   H235Params paramS;
+   ASN1DynOctStr encryptedData;
+} H235ENCRYPTED;
+
+EXTERN int asn1PE_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue);
+
+EXTERN int asn1PD_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoEncryptedToken                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235CryptoToken_cryptoEncryptedToken {
+   ASN1OBJID tokenOID;
+   H235ENCRYPTED token;
+} H235CryptoToken_cryptoEncryptedToken;
+
+EXTERN int asn1PE_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue);
+
+EXTERN int asn1PD_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedGeneralToken                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1OpenType H235EncodedGeneralToken;
+
+EXTERN int asn1PE_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken value);
+
+EXTERN int asn1PD_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoSignedToken_token                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235CryptoToken_cryptoSignedToken_token {
+   H235EncodedGeneralToken toBeSigned;
+   ASN1OBJID algorithmOID;
+   H235Params paramS;
+   ASN1DynBitStr signature;
+} H235CryptoToken_cryptoSignedToken_token;
+
+EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue);
+
+EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoSignedToken                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235CryptoToken_cryptoSignedToken {
+   ASN1OBJID tokenOID;
+   H235CryptoToken_cryptoSignedToken_token token;
+} H235CryptoToken_cryptoSignedToken;
+
+EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue);
+
+EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  HASHED                                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235HASHED {
+   ASN1OBJID algorithmOID;
+   H235Params paramS;
+   ASN1DynBitStr hash;
+} H235HASHED;
+
+EXTERN int asn1PE_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue);
+
+EXTERN int asn1PD_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoHashedToken                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H235CryptoToken_cryptoHashedToken {
+   ASN1OBJID tokenOID;
+   H235ClearToken hashedVals;
+   H235HASHED token;
+} H235CryptoToken_cryptoHashedToken;
+
+EXTERN int asn1PE_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue);
+
+EXTERN int asn1PD_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken                                               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H235CryptoToken_cryptoEncryptedToken 1
+#define T_H235CryptoToken_cryptoSignedToken 2
+#define T_H235CryptoToken_cryptoHashedToken 3
+#define T_H235CryptoToken_cryptoPwdEncr 4
+#define T_H235CryptoToken_extElem1      5
+
+typedef struct EXTERN H235CryptoToken {
+   int t;
+   union {
+      /* t = 1 */
+      H235CryptoToken_cryptoEncryptedToken *cryptoEncryptedToken;
+      /* t = 2 */
+      H235CryptoToken_cryptoSignedToken *cryptoSignedToken;
+      /* t = 3 */
+      H235CryptoToken_cryptoHashedToken *cryptoHashedToken;
+      /* t = 4 */
+      H235ENCRYPTED *cryptoPwdEncr;
+      /* t = 5 */
+   } u;
+} H235CryptoToken;
+
+EXTERN int asn1PE_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue);
+
+EXTERN int asn1PD_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESDec.c b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESDec.c
new file mode 100644
index 000000000..897bf0eec
--- /dev/null
+++ b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESDec.c
@@ -0,0 +1,1782 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#include "ooasn1.h"
+#include "H235-SECURITY-MESSAGES.h"
+#include "eventHandler.h"
+
+/**************************************************************/
+/*                                                            */
+/*  ChallengeString                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 8, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TimeStamp                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUnsigned (pctxt, pvalue, 1U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RandomVal                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235RandomVal (OOCTXT* pctxt, H235RandomVal* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeUnconsInteger (pctxt, pvalue);
+   if (stat != ASN_OK) return stat;
+   invokeIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Password                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235Password (OOCTXT* pctxt, H235Password* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBMPString (pctxt, pvalue, 0);
+   if (stat != ASN_OK) return stat;
+   invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedPwdCertToken                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeOpenType (pctxt, &pvalue->data, &pvalue->numocts);
+   if (stat != ASN_OK) return stat;
+   invokeOpenTypeValue
+      (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode nonStandardIdentifier */
+
+   invokeStartElement (pctxt, "nonStandardIdentifier", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->nonStandardIdentifier);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->nonStandardIdentifier.numids, pvalue->nonStandardIdentifier.subid);
+
+   invokeEndElement (pctxt, "nonStandardIdentifier", -1);
+
+   /* decode data */
+
+   invokeStartElement (pctxt, "data", -1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->data);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->data.numocts, pvalue->data.data);
+
+   invokeEndElement (pctxt, "data", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationBES                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* default_ */
+         case 0:
+            invokeStartElement (pctxt, "default_", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "default_", -1);
+
+            break;
+
+         /* radius */
+         case 1:
+            invokeStartElement (pctxt, "radius", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "radius", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationMechanism                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* dhExch */
+         case 0:
+            invokeStartElement (pctxt, "dhExch", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "dhExch", -1);
+
+            break;
+
+         /* pwdSymEnc */
+         case 1:
+            invokeStartElement (pctxt, "pwdSymEnc", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "pwdSymEnc", -1);
+
+            break;
+
+         /* pwdHash */
+         case 2:
+            invokeStartElement (pctxt, "pwdHash", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "pwdHash", -1);
+
+            break;
+
+         /* certSign */
+         case 3:
+            invokeStartElement (pctxt, "certSign", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "certSign", -1);
+
+            break;
+
+         /* ipsec */
+         case 4:
+            invokeStartElement (pctxt, "ipsec", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "ipsec", -1);
+
+            break;
+
+         /* tls */
+         case 5:
+            invokeStartElement (pctxt, "tls", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "tls", -1);
+
+            break;
+
+         /* nonStandard */
+         case 6:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H235NonStandardParameter);
+
+            stat = asn1PD_H235NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 8;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* authenticationBES */
+         case 8:
+            invokeStartElement (pctxt, "authenticationBES", -1);
+
+            pvalue->u.authenticationBES = ALLOC_ASN1ELEM (pctxt, H235AuthenticationBES);
+
+            stat = asn1PD_H235AuthenticationBES (pctxt, pvalue->u.authenticationBES);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "authenticationBES", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_halfkey                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_modSize                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_generator                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DHset                                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235DHset (OOCTXT* pctxt, H235DHset* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode halfkey */
+
+   invokeStartElement (pctxt, "halfkey", -1);
+
+   stat = asn1PD_H235DHset_halfkey (pctxt, &pvalue->halfkey);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "halfkey", -1);
+
+   /* decode modSize */
+
+   invokeStartElement (pctxt, "modSize", -1);
+
+   stat = asn1PD_H235DHset_modSize (pctxt, &pvalue->modSize);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "modSize", -1);
+
+   /* decode generator */
+
+   invokeStartElement (pctxt, "generator", -1);
+
+   stat = asn1PD_H235DHset_generator (pctxt, &pvalue->generator);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "generator", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TypedCertificate                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->type.numids, pvalue->type.subid);
+
+   invokeEndElement (pctxt, "type", -1);
+
+   /* decode certificate */
+
+   invokeStartElement (pctxt, "certificate", -1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->certificate);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->certificate.numocts, pvalue->certificate.data);
+
+   invokeEndElement (pctxt, "certificate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Identifier                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235Identifier (OOCTXT* pctxt, H235Identifier* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBMPString (pctxt, pvalue, 0);
+   if (stat != ASN_OK) return stat;
+   invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint_x                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint_y                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.xPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.yPresent = optbit;
+
+   /* decode x */
+
+   if (pvalue->m.xPresent) {
+      invokeStartElement (pctxt, "x", -1);
+
+      stat = asn1PD_H235ECpoint_x (pctxt, &pvalue->x);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "x", -1);
+   }
+
+   /* decode y */
+
+   if (pvalue->m.yPresent) {
+      invokeStartElement (pctxt, "y", -1);
+
+      stat = asn1PD_H235ECpoint_y (pctxt, &pvalue->y);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "y", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_modulus                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_weierstrassA                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_weierstrassB                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode public_key */
+
+   invokeStartElement (pctxt, "public_key", -1);
+
+   stat = asn1PD_H235ECpoint (pctxt, &pvalue->public_key);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "public_key", -1);
+
+   /* decode modulus */
+
+   invokeStartElement (pctxt, "modulus", -1);
+
+   stat = asn1PD_H235ECKASDH_eckasdhp_modulus (pctxt, &pvalue->modulus);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "modulus", -1);
+
+   /* decode base */
+
+   invokeStartElement (pctxt, "base", -1);
+
+   stat = asn1PD_H235ECpoint (pctxt, &pvalue->base);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "base", -1);
+
+   /* decode weierstrassA */
+
+   invokeStartElement (pctxt, "weierstrassA", -1);
+
+   stat = asn1PD_H235ECKASDH_eckasdhp_weierstrassA (pctxt, &pvalue->weierstrassA);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "weierstrassA", -1);
+
+   /* decode weierstrassB */
+
+   invokeStartElement (pctxt, "weierstrassB", -1);
+
+   stat = asn1PD_H235ECKASDH_eckasdhp_weierstrassB (pctxt, &pvalue->weierstrassB);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "weierstrassB", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_fieldSize                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_weierstrassA                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_weierstrassB                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode public_key */
+
+   invokeStartElement (pctxt, "public_key", -1);
+
+   stat = asn1PD_H235ECpoint (pctxt, &pvalue->public_key);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "public_key", -1);
+
+   /* decode fieldSize */
+
+   invokeStartElement (pctxt, "fieldSize", -1);
+
+   stat = asn1PD_H235ECKASDH_eckasdh2_fieldSize (pctxt, &pvalue->fieldSize);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "fieldSize", -1);
+
+   /* decode base */
+
+   invokeStartElement (pctxt, "base", -1);
+
+   stat = asn1PD_H235ECpoint (pctxt, &pvalue->base);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "base", -1);
+
+   /* decode weierstrassA */
+
+   invokeStartElement (pctxt, "weierstrassA", -1);
+
+   stat = asn1PD_H235ECKASDH_eckasdh2_weierstrassA (pctxt, &pvalue->weierstrassA);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "weierstrassA", -1);
+
+   /* decode weierstrassB */
+
+   invokeStartElement (pctxt, "weierstrassB", -1);
+
+   stat = asn1PD_H235ECKASDH_eckasdh2_weierstrassB (pctxt, &pvalue->weierstrassB);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "weierstrassB", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* eckasdhp */
+         case 0:
+            invokeStartElement (pctxt, "eckasdhp", -1);
+
+            pvalue->u.eckasdhp = ALLOC_ASN1ELEM (pctxt, H235ECKASDH_eckasdhp);
+
+            stat = asn1PD_H235ECKASDH_eckasdhp (pctxt, pvalue->u.eckasdhp);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "eckasdhp", -1);
+
+            break;
+
+         /* eckasdh2 */
+         case 1:
+            invokeStartElement (pctxt, "eckasdh2", -1);
+
+            pvalue->u.eckasdh2 = ALLOC_ASN1ELEM (pctxt, H235ECKASDH_eckasdh2);
+
+            stat = asn1PD_H235ECKASDH_eckasdh2 (pctxt, pvalue->u.eckasdh2);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "eckasdh2", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ClearToken                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.timeStampPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.passwordPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.dhkeyPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.challengePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.randomPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.certificatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.generalIDPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   /* decode tokenOID */
+
+   invokeStartElement (pctxt, "tokenOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);
+
+   invokeEndElement (pctxt, "tokenOID", -1);
+
+   /* decode timeStamp */
+
+   if (pvalue->m.timeStampPresent) {
+      invokeStartElement (pctxt, "timeStamp", -1);
+
+      stat = asn1PD_H235TimeStamp (pctxt, &pvalue->timeStamp);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "timeStamp", -1);
+   }
+
+   /* decode password */
+
+   if (pvalue->m.passwordPresent) {
+      invokeStartElement (pctxt, "password", -1);
+
+      stat = asn1PD_H235Password (pctxt, &pvalue->password);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "password", -1);
+   }
+
+   /* decode dhkey */
+
+   if (pvalue->m.dhkeyPresent) {
+      invokeStartElement (pctxt, "dhkey", -1);
+
+      stat = asn1PD_H235DHset (pctxt, &pvalue->dhkey);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "dhkey", -1);
+   }
+
+   /* decode challenge */
+
+   if (pvalue->m.challengePresent) {
+      invokeStartElement (pctxt, "challenge", -1);
+
+      stat = asn1PD_H235ChallengeString (pctxt, &pvalue->challenge);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "challenge", -1);
+   }
+
+   /* decode random */
+
+   if (pvalue->m.randomPresent) {
+      invokeStartElement (pctxt, "random", -1);
+
+      stat = asn1PD_H235RandomVal (pctxt, &pvalue->random);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "random", -1);
+   }
+
+   /* decode certificate */
+
+   if (pvalue->m.certificatePresent) {
+      invokeStartElement (pctxt, "certificate", -1);
+
+      stat = asn1PD_H235TypedCertificate (pctxt, &pvalue->certificate);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "certificate", -1);
+   }
+
+   /* decode generalID */
+
+   if (pvalue->m.generalIDPresent) {
+      invokeStartElement (pctxt, "generalID", -1);
+
+      stat = asn1PD_H235Identifier (pctxt, &pvalue->generalID);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "generalID", -1);
+   }
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H235NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.eckasdhkeyPresent = 1;
+
+                     invokeStartElement (pctxt, "eckasdhkey", -1);
+
+                     stat = asn1PD_H235ECKASDH (pctxt, &pvalue->eckasdhkey);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "eckasdhkey", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.sendersIDPresent = 1;
+
+                     invokeStartElement (pctxt, "sendersID", -1);
+
+                     stat = asn1PD_H235Identifier (pctxt, &pvalue->sendersID);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "sendersID", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IV8                                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 8, 8, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IV16                                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Params                                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235Params (OOCTXT* pctxt, H235Params* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.ranIntPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.iv8Present = optbit;
+
+   /* decode ranInt */
+
+   if (pvalue->m.ranIntPresent) {
+      invokeStartElement (pctxt, "ranInt", -1);
+
+      stat = decodeUnconsInteger (pctxt, &pvalue->ranInt);
+      if (stat != ASN_OK) return stat;
+      invokeIntValue (pctxt, pvalue->ranInt);
+
+      invokeEndElement (pctxt, "ranInt", -1);
+   }
+
+   /* decode iv8 */
+
+   if (pvalue->m.iv8Present) {
+      invokeStartElement (pctxt, "iv8", -1);
+
+      stat = asn1PD_H235IV8 (pctxt, &pvalue->iv8);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "iv8", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.iv16Present = 1;
+
+                     invokeStartElement (pctxt, "iv16", -1);
+
+                     stat = asn1PD_H235IV16 (pctxt, &pvalue->iv16);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "iv16", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ENCRYPTED                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode algorithmOID */
+
+   invokeStartElement (pctxt, "algorithmOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
+
+   invokeEndElement (pctxt, "algorithmOID", -1);
+
+   /* decode paramS */
+
+   invokeStartElement (pctxt, "paramS", -1);
+
+   stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "paramS", -1);
+
+   /* decode encryptedData */
+
+   invokeStartElement (pctxt, "encryptedData", -1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->encryptedData);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->encryptedData.numocts, pvalue->encryptedData.data);
+
+   invokeEndElement (pctxt, "encryptedData", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoEncryptedToken                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode tokenOID */
+
+   invokeStartElement (pctxt, "tokenOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);
+
+   invokeEndElement (pctxt, "tokenOID", -1);
+
+   /* decode token */
+
+   invokeStartElement (pctxt, "token", -1);
+
+   stat = asn1PD_H235ENCRYPTED (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "token", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedGeneralToken                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeOpenType (pctxt, &pvalue->data, &pvalue->numocts);
+   if (stat != ASN_OK) return stat;
+   invokeOpenTypeValue
+      (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoSignedToken_token                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode toBeSigned */
+
+   invokeStartElement (pctxt, "toBeSigned", -1);
+
+   stat = asn1PD_H235EncodedGeneralToken (pctxt, &pvalue->toBeSigned);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "toBeSigned", -1);
+
+   /* decode algorithmOID */
+
+   invokeStartElement (pctxt, "algorithmOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
+
+   invokeEndElement (pctxt, "algorithmOID", -1);
+
+   /* decode paramS */
+
+   invokeStartElement (pctxt, "paramS", -1);
+
+   stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "paramS", -1);
+
+   /* decode signature */
+
+   invokeStartElement (pctxt, "signature", -1);
+
+   stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->signature);
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->signature.numbits, pvalue->signature.data);
+
+   invokeEndElement (pctxt, "signature", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoSignedToken                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode tokenOID */
+
+   invokeStartElement (pctxt, "tokenOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);
+
+   invokeEndElement (pctxt, "tokenOID", -1);
+
+   /* decode token */
+
+   invokeStartElement (pctxt, "token", -1);
+
+   stat = asn1PD_H235CryptoToken_cryptoSignedToken_token (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "token", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  HASHED                                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode algorithmOID */
+
+   invokeStartElement (pctxt, "algorithmOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
+
+   invokeEndElement (pctxt, "algorithmOID", -1);
+
+   /* decode paramS */
+
+   invokeStartElement (pctxt, "paramS", -1);
+
+   stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "paramS", -1);
+
+   /* decode hash */
+
+   invokeStartElement (pctxt, "hash", -1);
+
+   stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->hash);
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->hash.numbits, pvalue->hash.data);
+
+   invokeEndElement (pctxt, "hash", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoHashedToken                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode tokenOID */
+
+   invokeStartElement (pctxt, "tokenOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);
+
+   invokeEndElement (pctxt, "tokenOID", -1);
+
+   /* decode hashedVals */
+
+   invokeStartElement (pctxt, "hashedVals", -1);
+
+   stat = asn1PD_H235ClearToken (pctxt, &pvalue->hashedVals);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "hashedVals", -1);
+
+   /* decode token */
+
+   invokeStartElement (pctxt, "token", -1);
+
+   stat = asn1PD_H235HASHED (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "token", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* cryptoEncryptedToken */
+         case 0:
+            invokeStartElement (pctxt, "cryptoEncryptedToken", -1);
+
+            pvalue->u.cryptoEncryptedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoEncryptedToken);
+
+            stat = asn1PD_H235CryptoToken_cryptoEncryptedToken (pctxt, pvalue->u.cryptoEncryptedToken);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoEncryptedToken", -1);
+
+            break;
+
+         /* cryptoSignedToken */
+         case 1:
+            invokeStartElement (pctxt, "cryptoSignedToken", -1);
+
+            pvalue->u.cryptoSignedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoSignedToken);
+
+            stat = asn1PD_H235CryptoToken_cryptoSignedToken (pctxt, pvalue->u.cryptoSignedToken);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoSignedToken", -1);
+
+            break;
+
+         /* cryptoHashedToken */
+         case 2:
+            invokeStartElement (pctxt, "cryptoHashedToken", -1);
+
+            pvalue->u.cryptoHashedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoHashedToken);
+
+            stat = asn1PD_H235CryptoToken_cryptoHashedToken (pctxt, pvalue->u.cryptoHashedToken);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoHashedToken", -1);
+
+            break;
+
+         /* cryptoPwdEncr */
+         case 3:
+            invokeStartElement (pctxt, "cryptoPwdEncr", -1);
+
+            pvalue->u.cryptoPwdEncr = ALLOC_ASN1ELEM (pctxt, H235ENCRYPTED);
+
+            stat = asn1PD_H235ENCRYPTED (pctxt, pvalue->u.cryptoPwdEncr);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoPwdEncr", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
diff --git a/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESEnc.c b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESEnc.c
new file mode 100644
index 000000000..8530c5198
--- /dev/null
+++ b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESEnc.c
@@ -0,0 +1,1269 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#include "ooasn1.h"
+#include "H235-SECURITY-MESSAGES.h"
+
+/**************************************************************/
+/*                                                            */
+/*  ChallengeString                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 8, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TimeStamp                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 1U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RandomVal                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235RandomVal (OOCTXT* pctxt, H235RandomVal value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeUnconsInteger (pctxt, value);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Password                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235Password (OOCTXT* pctxt, H235Password value)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBMPString (pctxt, value, 0);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedPwdCertToken                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeOpenType (pctxt, value.numocts, value.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode nonStandardIdentifier */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->nonStandardIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode data */
+
+   stat = encodeOctetString (pctxt, pvalue->data.numocts, pvalue->data.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationBES                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* default_ */
+         case 1:
+            /* NULL */
+            break;
+
+         /* radius */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationMechanism                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 7);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* dhExch */
+         case 1:
+            /* NULL */
+            break;
+
+         /* pwdSymEnc */
+         case 2:
+            /* NULL */
+            break;
+
+         /* pwdHash */
+         case 3:
+            /* NULL */
+            break;
+
+         /* certSign */
+         case 4:
+            /* NULL */
+            break;
+
+         /* ipsec */
+         case 5:
+            /* NULL */
+            break;
+
+         /* tls */
+         case 6:
+            /* NULL */
+            break;
+
+         /* nonStandard */
+         case 7:
+            stat = asn1PE_H235NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* authenticationBES */
+         case 8:
+            stat = asn1PE_H235AuthenticationBES (&lctxt, pvalue->u.authenticationBES);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_halfkey                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_modSize                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DHset_generator                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DHset                                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235DHset (OOCTXT* pctxt, H235DHset* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode halfkey */
+
+   stat = asn1PE_H235DHset_halfkey (pctxt, &pvalue->halfkey);
+   if (stat != ASN_OK) return stat;
+
+   /* encode modSize */
+
+   stat = asn1PE_H235DHset_modSize (pctxt, &pvalue->modSize);
+   if (stat != ASN_OK) return stat;
+
+   /* encode generator */
+
+   stat = asn1PE_H235DHset_generator (pctxt, &pvalue->generator);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TypedCertificate                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   /* encode certificate */
+
+   stat = encodeOctetString (pctxt, pvalue->certificate.numocts, pvalue->certificate.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Identifier                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235Identifier (OOCTXT* pctxt, H235Identifier value)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBMPString (pctxt, value, 0);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint_x                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint_y                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECpoint                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.xPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.yPresent);
+
+   /* encode x */
+
+   if (pvalue->m.xPresent) {
+      stat = asn1PE_H235ECpoint_x (pctxt, &pvalue->x);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode y */
+
+   if (pvalue->m.yPresent) {
+      stat = asn1PE_H235ECpoint_y (pctxt, &pvalue->y);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_modulus                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_weierstrassA                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp_weierstrassB                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdhp                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode public_key */
+
+   stat = asn1PE_H235ECpoint (pctxt, &pvalue->public_key);
+   if (stat != ASN_OK) return stat;
+
+   /* encode modulus */
+
+   stat = asn1PE_H235ECKASDH_eckasdhp_modulus (pctxt, &pvalue->modulus);
+   if (stat != ASN_OK) return stat;
+
+   /* encode base */
+
+   stat = asn1PE_H235ECpoint (pctxt, &pvalue->base);
+   if (stat != ASN_OK) return stat;
+
+   /* encode weierstrassA */
+
+   stat = asn1PE_H235ECKASDH_eckasdhp_weierstrassA (pctxt, &pvalue->weierstrassA);
+   if (stat != ASN_OK) return stat;
+
+   /* encode weierstrassB */
+
+   stat = asn1PE_H235ECKASDH_eckasdhp_weierstrassB (pctxt, &pvalue->weierstrassB);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_fieldSize                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_weierstrassA                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2_weierstrassB                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH_eckasdh2                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode public_key */
+
+   stat = asn1PE_H235ECpoint (pctxt, &pvalue->public_key);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fieldSize */
+
+   stat = asn1PE_H235ECKASDH_eckasdh2_fieldSize (pctxt, &pvalue->fieldSize);
+   if (stat != ASN_OK) return stat;
+
+   /* encode base */
+
+   stat = asn1PE_H235ECpoint (pctxt, &pvalue->base);
+   if (stat != ASN_OK) return stat;
+
+   /* encode weierstrassA */
+
+   stat = asn1PE_H235ECKASDH_eckasdh2_weierstrassA (pctxt, &pvalue->weierstrassA);
+   if (stat != ASN_OK) return stat;
+
+   /* encode weierstrassB */
+
+   stat = asn1PE_H235ECKASDH_eckasdh2_weierstrassB (pctxt, &pvalue->weierstrassB);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ECKASDH                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* eckasdhp */
+         case 1:
+            stat = asn1PE_H235ECKASDH_eckasdhp (pctxt, pvalue->u.eckasdhp);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* eckasdh2 */
+         case 2:
+            stat = asn1PE_H235ECKASDH_eckasdh2 (pctxt, pvalue->u.eckasdh2);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ClearToken                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.eckasdhkeyPresent ||
+   pvalue->m.sendersIDPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.timeStampPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.passwordPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.dhkeyPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.challengePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.randomPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.certificatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.generalIDPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   /* encode tokenOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode timeStamp */
+
+   if (pvalue->m.timeStampPresent) {
+      stat = asn1PE_H235TimeStamp (pctxt, pvalue->timeStamp);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode password */
+
+   if (pvalue->m.passwordPresent) {
+      stat = asn1PE_H235Password (pctxt, pvalue->password);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode dhkey */
+
+   if (pvalue->m.dhkeyPresent) {
+      stat = asn1PE_H235DHset (pctxt, &pvalue->dhkey);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode challenge */
+
+   if (pvalue->m.challengePresent) {
+      stat = asn1PE_H235ChallengeString (pctxt, &pvalue->challenge);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode random */
+
+   if (pvalue->m.randomPresent) {
+      stat = asn1PE_H235RandomVal (pctxt, pvalue->random);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode certificate */
+
+   if (pvalue->m.certificatePresent) {
+      stat = asn1PE_H235TypedCertificate (pctxt, &pvalue->certificate);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode generalID */
+
+   if (pvalue->m.generalIDPresent) {
+      stat = asn1PE_H235Identifier (pctxt, pvalue->generalID);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H235NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.eckasdhkeyPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.sendersIDPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.eckasdhkeyPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H235ECKASDH (&lctxt, &pvalue->eckasdhkey);
+         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.sendersIDPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H235Identifier (&lctxt, pvalue->sendersID);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IV8                                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 8, 8, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IV16                                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Params                                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235Params (OOCTXT* pctxt, H235Params* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.iv16Present);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.ranIntPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.iv8Present);
+
+   /* encode ranInt */
+
+   if (pvalue->m.ranIntPresent) {
+      stat = encodeUnconsInteger (pctxt, pvalue->ranInt);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode iv8 */
+
+   if (pvalue->m.iv8Present) {
+      stat = asn1PE_H235IV8 (pctxt, &pvalue->iv8);
+      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.iv16Present);
+      /* encode extension elements */
+
+      if (pvalue->m.iv16Present) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H235IV16 (&lctxt, &pvalue->iv16);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ENCRYPTED                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode algorithmOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode paramS */
+
+   stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   /* encode encryptedData */
+
+   stat = encodeOctetString (pctxt, pvalue->encryptedData.numocts, pvalue->encryptedData.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoEncryptedToken                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode tokenOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode token */
+
+   stat = asn1PE_H235ENCRYPTED (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedGeneralToken                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeOpenType (pctxt, value.numocts, value.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoSignedToken_token                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode toBeSigned */
+
+   stat = asn1PE_H235EncodedGeneralToken (pctxt, pvalue->toBeSigned);
+   if (stat != ASN_OK) return stat;
+
+   /* encode algorithmOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode paramS */
+
+   stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   /* encode signature */
+
+   stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoSignedToken                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode tokenOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode token */
+
+   stat = asn1PE_H235CryptoToken_cryptoSignedToken_token (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  HASHED                                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode algorithmOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode paramS */
+
+   stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   /* encode hash */
+
+   stat = encodeBitString (pctxt, pvalue->hash.numbits, pvalue->hash.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken_cryptoHashedToken                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode tokenOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode hashedVals */
+
+   stat = asn1PE_H235ClearToken (pctxt, &pvalue->hashedVals);
+   if (stat != ASN_OK) return stat;
+
+   /* encode token */
+
+   stat = asn1PE_H235HASHED (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoToken                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* cryptoEncryptedToken */
+         case 1:
+            stat = asn1PE_H235CryptoToken_cryptoEncryptedToken (pctxt, pvalue->u.cryptoEncryptedToken);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoSignedToken */
+         case 2:
+            stat = asn1PE_H235CryptoToken_cryptoSignedToken (pctxt, pvalue->u.cryptoSignedToken);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoHashedToken */
+         case 3:
+            stat = asn1PE_H235CryptoToken_cryptoHashedToken (pctxt, pvalue->u.cryptoHashedToken);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoPwdEncr */
+         case 4:
+            stat = asn1PE_H235ENCRYPTED (pctxt, pvalue->u.cryptoPwdEncr);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
diff --git a/addons/ooh323c/src/h323/H323-MESSAGES.c b/addons/ooh323c/src/h323/H323-MESSAGES.c
new file mode 100644
index 000000000..2c27f3b93
--- /dev/null
+++ b/addons/ooh323c/src/h323/H323-MESSAGES.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#include "ooasn1.h"
+#include "H323-MESSAGES.h"
+
+/**************************************************************/
+/*                                                            */
+/*  NumberDigits                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN const char* gs_H323_MESSAGES_NumberDigits_CharSet =
+"#*,0123456789";
+
+/**************************************************************/
+/*                                                            */
+/*  TBCD_STRING                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN const char* gs_H323_MESSAGES_TBCD_STRING_CharSet =
+"#*0123456789abc";
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_system_id                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet =
+"#*0123456789abc";
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet =
+"#*0123456789abc";
+
+/**************************************************************/
+/*                                                            */
+/*  GSM_UIM                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imsi_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imei_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet =
+"#*0123456789abc";
+
+EXTERN const char* gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet =
+"#*0123456789abc";
+
+/**************************************************************/
+/*                                                            */
+/*  AliasAddress                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN const char* gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet =
+"#*,0123456789";
+
diff --git a/addons/ooh323c/src/h323/H323-MESSAGES.h b/addons/ooh323c/src/h323/H323-MESSAGES.h
new file mode 100644
index 000000000..fbd87b336
--- /dev/null
+++ b/addons/ooh323c/src/h323/H323-MESSAGES.h
@@ -0,0 +1,6510 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#ifndef H323_MESSAGES_H
+#define H323_MESSAGES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ooasn1.h"
+#include "H235-SECURITY-MESSAGES.h"
+#include "MULTIMEDIA-SYSTEM-CONTROL.h"
+
+/**************************************************************/
+/*                                                            */
+/*  ScreeningIndicator                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef enum {
+   userProvidedNotScreened = 0,
+   userProvidedVerifiedAndPassed = 1,
+   userProvidedVerifiedAndFailed = 2,
+   networkProvided = 3
+} H225ScreeningIndicator_Root;
+
+typedef ASN1UINT H225ScreeningIndicator;
+
+EXTERN int asn1PE_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator value);
+
+EXTERN int asn1PD_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NumberDigits                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1IA5String H225NumberDigits;
+
+EXTERN int asn1PE_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits value);
+
+EXTERN int asn1PD_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TBCD_STRING                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1IA5String H225TBCD_STRING;
+
+EXTERN int asn1PE_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING value);
+
+EXTERN int asn1PD_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GloballyUniqueID                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GloballyUniqueID {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H225GloballyUniqueID;
+
+EXTERN int asn1PE_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue);
+
+EXTERN int asn1PD_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef H225GloballyUniqueID H225ConferenceIdentifier;
+
+EXTERN int asn1PE_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue);
+
+EXTERN int asn1PD_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestSeqNum                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1USINT H225RequestSeqNum;
+
+EXTERN int asn1PE_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum value);
+
+EXTERN int asn1PD_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1BMPString H225GatekeeperIdentifier;
+
+EXTERN int asn1PE_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier value);
+
+EXTERN int asn1PD_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  BandWidth                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT H225BandWidth;
+
+EXTERN int asn1PE_H225BandWidth (OOCTXT* pctxt, H225BandWidth value);
+
+EXTERN int asn1PD_H225BandWidth (OOCTXT* pctxt, H225BandWidth* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallReferenceValue                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1USINT H225CallReferenceValue;
+
+EXTERN int asn1PE_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue value);
+
+EXTERN int asn1PD_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointIdentifier                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1BMPString H225EndpointIdentifier;
+
+EXTERN int asn1PE_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier value);
+
+EXTERN int asn1PD_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ProtocolIdentifier                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1OBJID H225ProtocolIdentifier;
+
+EXTERN int asn1PE_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier value);
+
+EXTERN int asn1PD_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TimeToLive                                                */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT H225TimeToLive;
+
+EXTERN int asn1PE_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive value);
+
+EXTERN int asn1PD_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H248PackagesDescriptor                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1DynOctStr H225H248PackagesDescriptor;
+
+EXTERN int asn1PE_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor value);
+
+EXTERN int asn1PD_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H248SignalsDescriptor                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1DynOctStr H225H248SignalsDescriptor;
+
+EXTERN int asn1PE_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor value);
+
+EXTERN int asn1PD_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GenericIdentifier                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225GenericIdentifier_standard 1
+#define T_H225GenericIdentifier_oid     2
+#define T_H225GenericIdentifier_nonStandard 3
+#define T_H225GenericIdentifier_extElem1 4
+
+typedef struct EXTERN H225GenericIdentifier {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1INT standard;
+      /* t = 2 */
+      ASN1OBJID *oid;
+      /* t = 3 */
+      H225GloballyUniqueID *nonStandard;
+      /* t = 4 */
+   } u;
+} H225GenericIdentifier;
+
+EXTERN int asn1PE_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue);
+
+EXTERN int asn1PD_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipAddress_ip                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipAddress_ip {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H225TransportAddress_ipAddress_ip;
+
+EXTERN int asn1PE_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipAddress                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipAddress {
+   H225TransportAddress_ipAddress_ip ip;
+   ASN1USINT port;
+} H225TransportAddress_ipAddress;
+
+EXTERN int asn1PE_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_ip                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipSourceRoute_ip {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H225TransportAddress_ipSourceRoute_ip;
+
+EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_route_element              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipSourceRoute_route_element {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H225TransportAddress_ipSourceRoute_route_element;
+
+EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportAddress_ipSourceRoute_route_element    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225_SeqOfH225TransportAddress_ipSourceRoute_route_element {
+   ASN1UINT n;
+   H225TransportAddress_ipSourceRoute_route_element *elem;
+} H225_SeqOfH225TransportAddress_ipSourceRoute_route_element;
+
+EXTERN int asn1PE_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_routing                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225TransportAddress_ipSourceRoute_routing_strict 1
+#define T_H225TransportAddress_ipSourceRoute_routing_loose 2
+#define T_H225TransportAddress_ipSourceRoute_routing_extElem1 3
+
+typedef struct EXTERN H225TransportAddress_ipSourceRoute_routing {
+   int t;
+} H225TransportAddress_ipSourceRoute_routing;
+
+EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipSourceRoute {
+   H225TransportAddress_ipSourceRoute_ip ip;
+   ASN1USINT port;
+   H225_SeqOfH225TransportAddress_ipSourceRoute_route_element route;
+   H225TransportAddress_ipSourceRoute_routing routing;
+} H225TransportAddress_ipSourceRoute;
+
+EXTERN int asn1PE_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_node                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipxAddress_node {
+   ASN1UINT numocts;
+   ASN1OCTET data[6];
+} H225TransportAddress_ipxAddress_node;
+
+EXTERN int asn1PE_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_netnum                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipxAddress_netnum {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H225TransportAddress_ipxAddress_netnum;
+
+EXTERN int asn1PE_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_port                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipxAddress_port {
+   ASN1UINT numocts;
+   ASN1OCTET data[2];
+} H225TransportAddress_ipxAddress_port;
+
+EXTERN int asn1PE_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ipxAddress {
+   H225TransportAddress_ipxAddress_node node;
+   H225TransportAddress_ipxAddress_netnum netnum;
+   H225TransportAddress_ipxAddress_port port;
+} H225TransportAddress_ipxAddress;
+
+EXTERN int asn1PE_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ip6Address_ip                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ip6Address_ip {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H225TransportAddress_ip6Address_ip;
+
+EXTERN int asn1PE_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ip6Address                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_ip6Address {
+   H225TransportAddress_ip6Address_ip ip;
+   ASN1USINT port;
+} H225TransportAddress_ip6Address;
+
+EXTERN int asn1PE_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_netBios                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_netBios {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H225TransportAddress_netBios;
+
+EXTERN int asn1PE_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_nsap                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportAddress_nsap {
+   ASN1UINT numocts;
+   ASN1OCTET data[20];
+} H225TransportAddress_nsap;
+
+EXTERN int asn1PE_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H221NonStandard                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H221NonStandard {
+   ASN1UINT8 t35CountryCode;
+   ASN1UINT8 t35Extension;
+   ASN1USINT manufacturerCode;
+} H225H221NonStandard;
+
+EXTERN int asn1PE_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue);
+
+EXTERN int asn1PD_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225NonStandardIdentifier_object 1
+#define T_H225NonStandardIdentifier_h221NonStandard 2
+#define T_H225NonStandardIdentifier_extElem1 3
+
+typedef struct EXTERN H225NonStandardIdentifier {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1OBJID *object;
+      /* t = 2 */
+      H225H221NonStandard *h221NonStandard;
+      /* t = 3 */
+   } u;
+} H225NonStandardIdentifier;
+
+EXTERN int asn1PE_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue);
+
+EXTERN int asn1PD_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225NonStandardParameter {
+   H225NonStandardIdentifier nonStandardIdentifier;
+   ASN1DynOctStr data;
+} H225NonStandardParameter;
+
+EXTERN int asn1PE_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue);
+
+EXTERN int asn1PD_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225TransportAddress_ipAddress 1
+#define T_H225TransportAddress_ipSourceRoute 2
+#define T_H225TransportAddress_ipxAddress 3
+#define T_H225TransportAddress_ip6Address 4
+#define T_H225TransportAddress_netBios  5
+#define T_H225TransportAddress_nsap     6
+#define T_H225TransportAddress_nonStandardAddress 7
+#define T_H225TransportAddress_extElem1 8
+
+typedef struct EXTERN H225TransportAddress {
+   int t;
+   union {
+      /* t = 1 */
+      H225TransportAddress_ipAddress *ipAddress;
+      /* t = 2 */
+      H225TransportAddress_ipSourceRoute *ipSourceRoute;
+      /* t = 3 */
+      H225TransportAddress_ipxAddress *ipxAddress;
+      /* t = 4 */
+      H225TransportAddress_ip6Address *ip6Address;
+      /* t = 5 */
+      H225TransportAddress_netBios *netBios;
+      /* t = 6 */
+      H225TransportAddress_nsap *nsap;
+      /* t = 7 */
+      H225NonStandardParameter *nonStandardAddress;
+      /* t = 8 */
+   } u;
+} H225TransportAddress;
+
+EXTERN int asn1PE_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue);
+
+EXTERN int asn1PD_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  PublicTypeOfNumber                                        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225PublicTypeOfNumber_unknown 1
+#define T_H225PublicTypeOfNumber_internationalNumber 2
+#define T_H225PublicTypeOfNumber_nationalNumber 3
+#define T_H225PublicTypeOfNumber_networkSpecificNumber 4
+#define T_H225PublicTypeOfNumber_subscriberNumber 5
+#define T_H225PublicTypeOfNumber_abbreviatedNumber 6
+#define T_H225PublicTypeOfNumber_extElem1 7
+
+typedef struct EXTERN H225PublicTypeOfNumber {
+   int t;
+} H225PublicTypeOfNumber;
+
+EXTERN int asn1PE_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue);
+
+EXTERN int asn1PD_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  PublicPartyNumber                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225PublicPartyNumber {
+   H225PublicTypeOfNumber publicTypeOfNumber;
+   H225NumberDigits publicNumberDigits;
+} H225PublicPartyNumber;
+
+EXTERN int asn1PE_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue);
+
+EXTERN int asn1PD_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  PrivateTypeOfNumber                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225PrivateTypeOfNumber_unknown 1
+#define T_H225PrivateTypeOfNumber_level2RegionalNumber 2
+#define T_H225PrivateTypeOfNumber_level1RegionalNumber 3
+#define T_H225PrivateTypeOfNumber_pISNSpecificNumber 4
+#define T_H225PrivateTypeOfNumber_localNumber 5
+#define T_H225PrivateTypeOfNumber_abbreviatedNumber 6
+#define T_H225PrivateTypeOfNumber_extElem1 7
+
+typedef struct EXTERN H225PrivateTypeOfNumber {
+   int t;
+} H225PrivateTypeOfNumber;
+
+EXTERN int asn1PE_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue);
+
+EXTERN int asn1PD_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  PrivatePartyNumber                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225PrivatePartyNumber {
+   H225PrivateTypeOfNumber privateTypeOfNumber;
+   H225NumberDigits privateNumberDigits;
+} H225PrivatePartyNumber;
+
+EXTERN int asn1PE_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue);
+
+EXTERN int asn1PD_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  PartyNumber                                               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225PartyNumber_e164Number    1
+#define T_H225PartyNumber_dataPartyNumber 2
+#define T_H225PartyNumber_telexPartyNumber 3
+#define T_H225PartyNumber_privateNumber 4
+#define T_H225PartyNumber_nationalStandardPartyNumber 5
+#define T_H225PartyNumber_extElem1      6
+
+typedef struct EXTERN H225PartyNumber {
+   int t;
+   union {
+      /* t = 1 */
+      H225PublicPartyNumber *e164Number;
+      /* t = 2 */
+      H225NumberDigits dataPartyNumber;
+      /* t = 3 */
+      H225NumberDigits telexPartyNumber;
+      /* t = 4 */
+      H225PrivatePartyNumber *privateNumber;
+      /* t = 5 */
+      H225NumberDigits nationalStandardPartyNumber;
+      /* t = 6 */
+   } u;
+} H225PartyNumber;
+
+EXTERN int asn1PE_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue);
+
+EXTERN int asn1PD_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_system_id                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225ANSI_41_UIM_system_id_sid 1
+#define T_H225ANSI_41_UIM_system_id_mid 2
+#define T_H225ANSI_41_UIM_system_id_extElem1 3
+
+typedef struct EXTERN H225ANSI_41_UIM_system_id {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1IA5String sid;
+      /* t = 2 */
+      ASN1IA5String mid;
+      /* t = 3 */
+   } u;
+} H225ANSI_41_UIM_system_id;
+
+EXTERN int asn1PE_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue);
+
+EXTERN int asn1PD_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_systemMyTypeCode                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ANSI_41_UIM_systemMyTypeCode {
+   ASN1UINT numocts;
+   ASN1OCTET data[1];
+} H225ANSI_41_UIM_systemMyTypeCode;
+
+EXTERN int asn1PE_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue);
+
+EXTERN int asn1PD_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_systemAccessType                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ANSI_41_UIM_systemAccessType {
+   ASN1UINT numocts;
+   ASN1OCTET data[1];
+} H225ANSI_41_UIM_systemAccessType;
+
+EXTERN int asn1PE_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue);
+
+EXTERN int asn1PD_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_qualificationInformationCode                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ANSI_41_UIM_qualificationInformationCode {
+   ASN1UINT numocts;
+   ASN1OCTET data[1];
+} H225ANSI_41_UIM_qualificationInformationCode;
+
+EXTERN int asn1PE_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue);
+
+EXTERN int asn1PD_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ANSI_41_UIM {
+   struct {
+      unsigned imsiPresent : 1;
+      unsigned minPresent : 1;
+      unsigned mdnPresent : 1;
+      unsigned msisdnPresent : 1;
+      unsigned esnPresent : 1;
+      unsigned mscidPresent : 1;
+      unsigned systemMyTypeCodePresent : 1;
+      unsigned systemAccessTypePresent : 1;
+      unsigned qualificationInformationCodePresent : 1;
+      unsigned sesnPresent : 1;
+      unsigned socPresent : 1;
+   } m;
+   ASN1IA5String imsi;
+   ASN1IA5String min;
+   ASN1IA5String mdn;
+   ASN1IA5String msisdn;
+   ASN1IA5String esn;
+   ASN1IA5String mscid;
+   H225ANSI_41_UIM_system_id system_id;
+   H225ANSI_41_UIM_systemMyTypeCode systemMyTypeCode;
+   H225ANSI_41_UIM_systemAccessType systemAccessType;
+   H225ANSI_41_UIM_qualificationInformationCode qualificationInformationCode;
+   ASN1IA5String sesn;
+   ASN1IA5String soc;
+} H225ANSI_41_UIM;
+
+EXTERN int asn1PE_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue);
+
+EXTERN int asn1PD_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GSM_UIM_tmsi                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GSM_UIM_tmsi {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H225GSM_UIM_tmsi;
+
+EXTERN int asn1PE_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue);
+
+EXTERN int asn1PD_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GSM_UIM                                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GSM_UIM {
+   struct {
+      unsigned imsiPresent : 1;
+      unsigned tmsiPresent : 1;
+      unsigned msisdnPresent : 1;
+      unsigned imeiPresent : 1;
+      unsigned hplmnPresent : 1;
+      unsigned vplmnPresent : 1;
+   } m;
+   ASN1IA5String imsi;
+   H225GSM_UIM_tmsi tmsi;
+   ASN1IA5String msisdn;
+   ASN1IA5String imei;
+   ASN1IA5String hplmn;
+   ASN1IA5String vplmn;
+} H225GSM_UIM;
+
+EXTERN int asn1PE_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue);
+
+EXTERN int asn1PD_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MobileUIM                                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225MobileUIM_ansi_41_uim     1
+#define T_H225MobileUIM_gsm_uim         2
+#define T_H225MobileUIM_extElem1        3
+
+typedef struct EXTERN H225MobileUIM {
+   int t;
+   union {
+      /* t = 1 */
+      H225ANSI_41_UIM *ansi_41_uim;
+      /* t = 2 */
+      H225GSM_UIM *gsm_uim;
+      /* t = 3 */
+   } u;
+} H225MobileUIM;
+
+EXTERN int asn1PE_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue);
+
+EXTERN int asn1PD_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AliasAddress                                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225AliasAddress_dialedDigits 1
+#define T_H225AliasAddress_h323_ID      2
+#define T_H225AliasAddress_url_ID       3
+#define T_H225AliasAddress_transportID  4
+#define T_H225AliasAddress_email_ID     5
+#define T_H225AliasAddress_partyNumber  6
+#define T_H225AliasAddress_mobileUIM    7
+#define T_H225AliasAddress_extElem1     8
+
+typedef struct EXTERN H225AliasAddress {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1IA5String dialedDigits;
+      /* t = 2 */
+      ASN1BMPString h323_ID;
+      /* t = 3 */
+      ASN1IA5String url_ID;
+      /* t = 4 */
+      H225TransportAddress *transportID;
+      /* t = 5 */
+      ASN1IA5String email_ID;
+      /* t = 6 */
+      H225PartyNumber *partyNumber;
+      /* t = 7 */
+      H225MobileUIM *mobileUIM;
+      /* t = 8 */
+   } u;
+} H225AliasAddress;
+
+EXTERN int asn1PE_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue);
+
+EXTERN int asn1PD_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Content_compound                                          */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225EnumeratedParameter */
+typedef DList H225Content_compound;
+
+EXTERN int asn1PE_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue);
+
+EXTERN int asn1PD_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Content_nested                                            */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225GenericData */
+typedef DList H225Content_nested;
+
+EXTERN int asn1PE_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue);
+
+EXTERN int asn1PD_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Content                                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225Content_raw               1
+#define T_H225Content_text              2
+#define T_H225Content_unicode           3
+#define T_H225Content_bool_             4
+#define T_H225Content_number8           5
+#define T_H225Content_number16          6
+#define T_H225Content_number32          7
+#define T_H225Content_id                8
+#define T_H225Content_alias             9
+#define T_H225Content_transport         10
+#define T_H225Content_compound          11
+#define T_H225Content_nested            12
+#define T_H225Content_extElem1          13
+
+typedef struct EXTERN H225Content {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1DynOctStr *raw;
+      /* t = 2 */
+      ASN1IA5String text;
+      /* t = 3 */
+      ASN1BMPString unicode;
+      /* t = 4 */
+      ASN1BOOL bool_;
+      /* t = 5 */
+      ASN1UINT8 number8;
+      /* t = 6 */
+      ASN1USINT number16;
+      /* t = 7 */
+      ASN1UINT number32;
+      /* t = 8 */
+      H225GenericIdentifier *id;
+      /* t = 9 */
+      H225AliasAddress *alias;
+      /* t = 10 */
+      H225TransportAddress *transport;
+      /* t = 11 */
+      H225Content_compound *compound;
+      /* t = 12 */
+      H225Content_nested *nested;
+      /* t = 13 */
+   } u;
+} H225Content;
+
+EXTERN int asn1PE_H225Content (OOCTXT* pctxt, H225Content* pvalue);
+
+EXTERN int asn1PD_H225Content (OOCTXT* pctxt, H225Content* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EnumeratedParameter                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225EnumeratedParameter {
+   struct {
+      unsigned contentPresent : 1;
+   } m;
+   H225GenericIdentifier id;
+   H225Content content;
+} H225EnumeratedParameter;
+
+EXTERN int asn1PE_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue);
+
+EXTERN int asn1PD_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GenericData_parameters                                    */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225EnumeratedParameter */
+typedef DList H225GenericData_parameters;
+
+EXTERN int asn1PE_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue);
+
+EXTERN int asn1PD_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GenericData                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GenericData {
+   struct {
+      unsigned parametersPresent : 1;
+   } m;
+   H225GenericIdentifier id;
+   H225GenericData_parameters parameters;
+} H225GenericData;
+
+EXTERN int asn1PE_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue);
+
+EXTERN int asn1PD_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FeatureDescriptor                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef H225GenericData H225FeatureDescriptor;
+
+EXTERN int asn1PE_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue);
+
+EXTERN int asn1PD_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FastStartToken                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef H235ClearToken H225FastStartToken;
+
+EXTERN int asn1PE_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue);
+
+EXTERN int asn1PD_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedFastStartToken                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1OpenType H225EncodedFastStartToken;
+
+EXTERN int asn1PE_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken value);
+
+EXTERN int asn1PD_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation_user_data_user_information           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323_UserInformation_user_data_user_information {
+   ASN1UINT numocts;
+   ASN1OCTET data[131];
+} H225H323_UserInformation_user_data_user_information;
+
+EXTERN int asn1PE_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue);
+
+EXTERN int asn1PD_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointType_set                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225EndpointType_set {
+   ASN1UINT  numbits;
+   ASN1OCTET data[4];
+} H225EndpointType_set;
+
+EXTERN int asn1PE_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue);
+
+EXTERN int asn1PD_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier_productId                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225VendorIdentifier_productId {
+   ASN1UINT numocts;
+   ASN1OCTET data[256];
+} H225VendorIdentifier_productId;
+
+EXTERN int asn1PE_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue);
+
+EXTERN int asn1PD_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier_versionId                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225VendorIdentifier_versionId {
+   ASN1UINT numocts;
+   ASN1OCTET data[256];
+} H225VendorIdentifier_versionId;
+
+EXTERN int asn1PE_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue);
+
+EXTERN int asn1PD_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo_cic_element                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CicInfo_cic_element {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H225CicInfo_cic_element;
+
+EXTERN int asn1PE_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue);
+
+EXTERN int asn1PD_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo_pointCode                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CicInfo_pointCode {
+   ASN1UINT numocts;
+   ASN1OCTET data[5];
+} H225CicInfo_pointCode;
+
+EXTERN int asn1PE_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue);
+
+EXTERN int asn1PD_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CarrierInfo_carrierIdentificationCode                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CarrierInfo_carrierIdentificationCode {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H225CarrierInfo_carrierIdentificationCode;
+
+EXTERN int asn1PE_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue);
+
+EXTERN int asn1PD_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallTerminationCause_releaseCompleteCauseIE               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallTerminationCause_releaseCompleteCauseIE {
+   ASN1UINT numocts;
+   ASN1OCTET data[32];
+} H225CallTerminationCause_releaseCompleteCauseIE;
+
+EXTERN int asn1PE_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue);
+
+EXTERN int asn1PD_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AliasAddress                                    */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225AliasAddress */
+typedef DList H225_SeqOfH225AliasAddress;
+
+EXTERN int asn1PE_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225VendorIdentifier {
+   struct {
+      unsigned productIdPresent : 1;
+      unsigned versionIdPresent : 1;
+      unsigned enterpriseNumberPresent : 1;
+   } m;
+   H225H221NonStandard vendor;
+   H225VendorIdentifier_productId productId;
+   H225VendorIdentifier_versionId versionId;
+   ASN1OBJID enterpriseNumber;
+} H225VendorIdentifier;
+
+EXTERN int asn1PE_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue);
+
+EXTERN int asn1PD_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperInfo                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GatekeeperInfo {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+} H225GatekeeperInfo;
+
+EXTERN int asn1PE_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue);
+
+EXTERN int asn1PD_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataRate                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225DataRate {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned channelMultiplierPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225BandWidth channelRate;
+   ASN1USINT channelMultiplier;
+} H225DataRate;
+
+EXTERN int asn1PE_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue);
+
+EXTERN int asn1PD_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225DataRate                                        */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225DataRate */
+typedef DList H225_SeqOfH225DataRate;
+
+EXTERN int asn1PE_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SupportedPrefix                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225SupportedPrefix {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225AliasAddress prefix;
+} H225SupportedPrefix;
+
+EXTERN int asn1PE_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue);
+
+EXTERN int asn1PD_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225SupportedPrefix                                 */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225SupportedPrefix */
+typedef DList H225_SeqOfH225SupportedPrefix;
+
+EXTERN int asn1PE_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H310Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H310Caps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225H310Caps;
+
+EXTERN int asn1PE_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue);
+
+EXTERN int asn1PD_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H320Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H320Caps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225H320Caps;
+
+EXTERN int asn1PE_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue);
+
+EXTERN int asn1PD_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H321Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H321Caps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225H321Caps;
+
+EXTERN int asn1PE_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue);
+
+EXTERN int asn1PD_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H322Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H322Caps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225H322Caps;
+
+EXTERN int asn1PE_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue);
+
+EXTERN int asn1PD_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323Caps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225H323Caps;
+
+EXTERN int asn1PE_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue);
+
+EXTERN int asn1PD_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H324Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H324Caps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225H324Caps;
+
+EXTERN int asn1PE_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue);
+
+EXTERN int asn1PD_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VoiceCaps                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225VoiceCaps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225VoiceCaps;
+
+EXTERN int asn1PE_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue);
+
+EXTERN int asn1PD_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T120OnlyCaps                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225T120OnlyCaps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225T120OnlyCaps;
+
+EXTERN int asn1PE_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue);
+
+EXTERN int asn1PD_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardProtocol                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225NonStandardProtocol {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225NonStandardProtocol;
+
+EXTERN int asn1PE_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue);
+
+EXTERN int asn1PD_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxAnnexbOnlyCaps                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225T38FaxAnnexbOnlyCaps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+   H245DataProtocolCapability t38FaxProtocol;
+   H245T38FaxProfile t38FaxProfile;
+} H225T38FaxAnnexbOnlyCaps;
+
+EXTERN int asn1PE_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue);
+
+EXTERN int asn1PD_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SIPCaps                                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225SIPCaps {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned dataRatesSupportedPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225DataRate dataRatesSupported;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225SIPCaps;
+
+EXTERN int asn1PE_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue);
+
+EXTERN int asn1PD_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SupportedProtocols                                        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225SupportedProtocols_nonStandardData 1
+#define T_H225SupportedProtocols_h310   2
+#define T_H225SupportedProtocols_h320   3
+#define T_H225SupportedProtocols_h321   4
+#define T_H225SupportedProtocols_h322   5
+#define T_H225SupportedProtocols_h323   6
+#define T_H225SupportedProtocols_h324   7
+#define T_H225SupportedProtocols_voice  8
+#define T_H225SupportedProtocols_t120_only 9
+#define T_H225SupportedProtocols_nonStandardProtocol 10
+#define T_H225SupportedProtocols_t38FaxAnnexbOnly 11
+#define T_H225SupportedProtocols_sip    12
+#define T_H225SupportedProtocols_extElem1 13
+
+typedef struct EXTERN H225SupportedProtocols {
+   int t;
+   union {
+      /* t = 1 */
+      H225NonStandardParameter *nonStandardData;
+      /* t = 2 */
+      H225H310Caps *h310;
+      /* t = 3 */
+      H225H320Caps *h320;
+      /* t = 4 */
+      H225H321Caps *h321;
+      /* t = 5 */
+      H225H322Caps *h322;
+      /* t = 6 */
+      H225H323Caps *h323;
+      /* t = 7 */
+      H225H324Caps *h324;
+      /* t = 8 */
+      H225VoiceCaps *voice;
+      /* t = 9 */
+      H225T120OnlyCaps *t120_only;
+      /* t = 10 */
+      H225NonStandardProtocol *nonStandardProtocol;
+      /* t = 11 */
+      H225T38FaxAnnexbOnlyCaps *t38FaxAnnexbOnly;
+      /* t = 12 */
+      H225SIPCaps *sip;
+      /* t = 13 */
+   } u;
+} H225SupportedProtocols;
+
+EXTERN int asn1PE_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue);
+
+EXTERN int asn1PD_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225SupportedProtocols                              */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225SupportedProtocols */
+typedef DList H225_SeqOfH225SupportedProtocols;
+
+EXTERN int asn1PE_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GatewayInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GatewayInfo {
+   struct {
+      unsigned protocolPresent : 1;
+      unsigned nonStandardDataPresent : 1;
+   } m;
+   H225_SeqOfH225SupportedProtocols protocol;
+   H225NonStandardParameter nonStandardData;
+} H225GatewayInfo;
+
+EXTERN int asn1PE_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue);
+
+EXTERN int asn1PD_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  McuInfo                                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225McuInfo {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned protocolPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225SupportedProtocols protocol;
+} H225McuInfo;
+
+EXTERN int asn1PE_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue);
+
+EXTERN int asn1PD_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalInfo                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TerminalInfo {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+} H225TerminalInfo;
+
+EXTERN int asn1PE_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue);
+
+EXTERN int asn1PD_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocolAlternateIdentifier                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TunnelledProtocolAlternateIdentifier {
+   struct {
+      unsigned protocolVariantPresent : 1;
+   } m;
+   ASN1IA5String protocolType;
+   ASN1IA5String protocolVariant;
+} H225TunnelledProtocolAlternateIdentifier;
+
+EXTERN int asn1PE_H225TunnelledProtocolAlternateIdentifier (OOCTXT* pctxt, H225TunnelledProtocolAlternateIdentifier* pvalue);
+
+EXTERN int asn1PD_H225TunnelledProtocolAlternateIdentifier (OOCTXT* pctxt, H225TunnelledProtocolAlternateIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocol_id                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225TunnelledProtocol_id_tunnelledProtocolObjectID 1
+#define T_H225TunnelledProtocol_id_tunnelledProtocolAlternateID 2
+#define T_H225TunnelledProtocol_id_extElem1 3
+
+typedef struct EXTERN H225TunnelledProtocol_id {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1OBJID *tunnelledProtocolObjectID;
+      /* t = 2 */
+      H225TunnelledProtocolAlternateIdentifier *tunnelledProtocolAlternateID;
+      /* t = 3 */
+   } u;
+} H225TunnelledProtocol_id;
+
+EXTERN int asn1PE_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue);
+
+EXTERN int asn1PD_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocol                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TunnelledProtocol {
+   struct {
+      unsigned subIdentifierPresent : 1;
+   } m;
+   H225TunnelledProtocol_id id;
+   ASN1IA5String subIdentifier;
+} H225TunnelledProtocol;
+
+EXTERN int asn1PE_H225TunnelledProtocol (OOCTXT* pctxt, H225TunnelledProtocol* pvalue);
+
+EXTERN int asn1PD_H225TunnelledProtocol (OOCTXT* pctxt, H225TunnelledProtocol* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TunnelledProtocol                               */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225TunnelledProtocol */
+typedef DList H225_SeqOfH225TunnelledProtocol;
+
+EXTERN int asn1PE_H225_SeqOfH225TunnelledProtocol (OOCTXT* pctxt, H225_SeqOfH225TunnelledProtocol* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225TunnelledProtocol (OOCTXT* pctxt, H225_SeqOfH225TunnelledProtocol* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointType                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225EndpointType {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned vendorPresent : 1;
+      unsigned gatekeeperPresent : 1;
+      unsigned gatewayPresent : 1;
+      unsigned mcuPresent : 1;
+      unsigned terminalPresent : 1;
+      unsigned setPresent : 1;
+      unsigned supportedTunnelledProtocolsPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225VendorIdentifier vendor;
+   H225GatekeeperInfo gatekeeper;
+   H225GatewayInfo gateway;
+   H225McuInfo mcu;
+   H225TerminalInfo terminal;
+   ASN1BOOL mc;
+   ASN1BOOL undefinedNode;
+   H225EndpointType_set set;
+   H225_SeqOfH225TunnelledProtocol supportedTunnelledProtocols;
+} H225EndpointType;
+
+EXTERN int asn1PE_H225EndpointType (OOCTXT* pctxt, H225EndpointType* pvalue);
+
+EXTERN int asn1PD_H225EndpointType (OOCTXT* pctxt, H225EndpointType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CallReferenceValue                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225_SeqOfH225CallReferenceValue {
+   ASN1UINT n;
+   H225CallReferenceValue *elem;
+} H225_SeqOfH225CallReferenceValue;
+
+EXTERN int asn1PE_H225_SeqOfH225CallReferenceValue (OOCTXT* pctxt, H225_SeqOfH225CallReferenceValue* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225CallReferenceValue (OOCTXT* pctxt, H225_SeqOfH225CallReferenceValue* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_conferenceGoal                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225Setup_UUIE_conferenceGoal_create 1
+#define T_H225Setup_UUIE_conferenceGoal_join 2
+#define T_H225Setup_UUIE_conferenceGoal_invite 3
+#define T_H225Setup_UUIE_conferenceGoal_capability_negotiation 4
+#define T_H225Setup_UUIE_conferenceGoal_callIndependentSupplementaryService 5
+#define T_H225Setup_UUIE_conferenceGoal_extElem1 6
+
+typedef struct EXTERN H225Setup_UUIE_conferenceGoal {
+   int t;
+} H225Setup_UUIE_conferenceGoal;
+
+EXTERN int asn1PE_H225Setup_UUIE_conferenceGoal (OOCTXT* pctxt, H225Setup_UUIE_conferenceGoal* pvalue);
+
+EXTERN int asn1PD_H225Setup_UUIE_conferenceGoal (OOCTXT* pctxt, H225Setup_UUIE_conferenceGoal* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Q954Details                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Q954Details {
+   ASN1BOOL conferenceCalling;
+   ASN1BOOL threePartyService;
+} H225Q954Details;
+
+EXTERN int asn1PE_H225Q954Details (OOCTXT* pctxt, H225Q954Details* pvalue);
+
+EXTERN int asn1PD_H225Q954Details (OOCTXT* pctxt, H225Q954Details* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  QseriesOptions                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225QseriesOptions {
+   ASN1BOOL q932Full;
+   ASN1BOOL q951Full;
+   ASN1BOOL q952Full;
+   ASN1BOOL q953Full;
+   ASN1BOOL q955Full;
+   ASN1BOOL q956Full;
+   ASN1BOOL q957Full;
+   H225Q954Details q954Info;
+} H225QseriesOptions;
+
+EXTERN int asn1PE_H225QseriesOptions (OOCTXT* pctxt, H225QseriesOptions* pvalue);
+
+EXTERN int asn1PD_H225QseriesOptions (OOCTXT* pctxt, H225QseriesOptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallType                                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225CallType_pointToPoint     1
+#define T_H225CallType_oneToN           2
+#define T_H225CallType_nToOne           3
+#define T_H225CallType_nToN             4
+#define T_H225CallType_extElem1         5
+
+typedef struct EXTERN H225CallType {
+   int t;
+} H225CallType;
+
+EXTERN int asn1PE_H225CallType (OOCTXT* pctxt, H225CallType* pvalue);
+
+EXTERN int asn1PD_H225CallType (OOCTXT* pctxt, H225CallType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallIdentifier                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallIdentifier {
+   H225GloballyUniqueID guid;
+} H225CallIdentifier;
+
+EXTERN int asn1PE_H225CallIdentifier (OOCTXT* pctxt, H225CallIdentifier* pvalue);
+
+EXTERN int asn1PD_H225CallIdentifier (OOCTXT* pctxt, H225CallIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityServiceMode                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225SecurityServiceMode_nonStandard 1
+#define T_H225SecurityServiceMode_none  2
+#define T_H225SecurityServiceMode_default_ 3
+#define T_H225SecurityServiceMode_extElem1 4
+
+typedef struct EXTERN H225SecurityServiceMode {
+   int t;
+   union {
+      /* t = 1 */
+      H225NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+   } u;
+} H225SecurityServiceMode;
+
+EXTERN int asn1PE_H225SecurityServiceMode (OOCTXT* pctxt, H225SecurityServiceMode* pvalue);
+
+EXTERN int asn1PD_H225SecurityServiceMode (OOCTXT* pctxt, H225SecurityServiceMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityCapabilities                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225SecurityCapabilities {
+   struct {
+      unsigned nonStandardPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandard;
+   H225SecurityServiceMode encryption;
+   H225SecurityServiceMode authenticaton;
+   H225SecurityServiceMode integrity;
+} H225SecurityCapabilities;
+
+EXTERN int asn1PE_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilities* pvalue);
+
+EXTERN int asn1PD_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilities* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H245Security                                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225H245Security_nonStandard  1
+#define T_H225H245Security_noSecurity   2
+#define T_H225H245Security_tls          3
+#define T_H225H245Security_ipsec        4
+#define T_H225H245Security_extElem1     5
+
+typedef struct EXTERN H225H245Security {
+   int t;
+   union {
+      /* t = 1 */
+      H225NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      H225SecurityCapabilities *tls;
+      /* t = 4 */
+      H225SecurityCapabilities *ipsec;
+      /* t = 5 */
+   } u;
+} H225H245Security;
+
+EXTERN int asn1PE_H225H245Security (OOCTXT* pctxt, H225H245Security* pvalue);
+
+EXTERN int asn1PD_H225H245Security (OOCTXT* pctxt, H225H245Security* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225H245Security                                    */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225H245Security */
+typedef DList H225_SeqOfH225H245Security;
+
+EXTERN int asn1PE_H225_SeqOfH225H245Security (OOCTXT* pctxt, H225_SeqOfH225H245Security* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225H245Security (OOCTXT* pctxt, H225_SeqOfH225H245Security* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ClearToken                                      */
+/*                                                            */
+/**************************************************************/
+
+/* List of H235ClearToken */
+typedef DList H225_SeqOfH225ClearToken;
+
+EXTERN int asn1PE_H225_SeqOfH225ClearToken (OOCTXT* pctxt, H225_SeqOfH225ClearToken* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225ClearToken (OOCTXT* pctxt, H225_SeqOfH225ClearToken* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoEPPwdHash                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CryptoH323Token_cryptoEPPwdHash {
+   H225AliasAddress alias;
+   H235TimeStamp timeStamp;
+   H235HASHED token;
+} H225CryptoH323Token_cryptoEPPwdHash;
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoEPPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPPwdHash* pvalue);
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoEPPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPPwdHash* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoGKPwdHash                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CryptoH323Token_cryptoGKPwdHash {
+   H225GatekeeperIdentifier gatekeeperId;
+   H235TimeStamp timeStamp;
+   H235HASHED token;
+} H225CryptoH323Token_cryptoGKPwdHash;
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoGKPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKPwdHash* pvalue);
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoGKPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKPwdHash* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoEPCert                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CryptoH323Token_cryptoEPCert {
+   H235EncodedPwdCertToken toBeSigned;
+   ASN1OBJID algorithmOID;
+   H235Params paramS;
+   ASN1DynBitStr signature;
+} H225CryptoH323Token_cryptoEPCert;
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoEPCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPCert* pvalue);
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoEPCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPCert* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoGKCert                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CryptoH323Token_cryptoGKCert {
+   H235EncodedPwdCertToken toBeSigned;
+   ASN1OBJID algorithmOID;
+   H235Params paramS;
+   ASN1DynBitStr signature;
+} H225CryptoH323Token_cryptoGKCert;
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoGKCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKCert* pvalue);
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoGKCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKCert* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoFastStart                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CryptoH323Token_cryptoFastStart {
+   H225EncodedFastStartToken toBeSigned;
+   ASN1OBJID algorithmOID;
+   H235Params paramS;
+   ASN1DynBitStr signature;
+} H225CryptoH323Token_cryptoFastStart;
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoFastStart (OOCTXT* pctxt, H225CryptoH323Token_cryptoFastStart* pvalue);
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoFastStart (OOCTXT* pctxt, H225CryptoH323Token_cryptoFastStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225CryptoH323Token_cryptoEPPwdHash 1
+#define T_H225CryptoH323Token_cryptoGKPwdHash 2
+#define T_H225CryptoH323Token_cryptoEPPwdEncr 3
+#define T_H225CryptoH323Token_cryptoGKPwdEncr 4
+#define T_H225CryptoH323Token_cryptoEPCert 5
+#define T_H225CryptoH323Token_cryptoGKCert 6
+#define T_H225CryptoH323Token_cryptoFastStart 7
+#define T_H225CryptoH323Token_nestedcryptoToken 8
+#define T_H225CryptoH323Token_extElem1  9
+
+typedef struct EXTERN H225CryptoH323Token {
+   int t;
+   union {
+      /* t = 1 */
+      H225CryptoH323Token_cryptoEPPwdHash *cryptoEPPwdHash;
+      /* t = 2 */
+      H225CryptoH323Token_cryptoGKPwdHash *cryptoGKPwdHash;
+      /* t = 3 */
+      H235ENCRYPTED *cryptoEPPwdEncr;
+      /* t = 4 */
+      H235ENCRYPTED *cryptoGKPwdEncr;
+      /* t = 5 */
+      H225CryptoH323Token_cryptoEPCert *cryptoEPCert;
+      /* t = 6 */
+      H225CryptoH323Token_cryptoGKCert *cryptoGKCert;
+      /* t = 7 */
+      H225CryptoH323Token_cryptoFastStart *cryptoFastStart;
+      /* t = 8 */
+      H235CryptoToken *nestedcryptoToken;
+      /* t = 9 */
+   } u;
+} H225CryptoH323Token;
+
+EXTERN int asn1PE_H225CryptoH323Token (OOCTXT* pctxt, H225CryptoH323Token* pvalue);
+
+EXTERN int asn1PD_H225CryptoH323Token (OOCTXT* pctxt, H225CryptoH323Token* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CryptoH323Token                                 */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225CryptoH323Token */
+typedef DList H225_SeqOfH225CryptoH323Token;
+
+EXTERN int asn1PE_H225_SeqOfH225CryptoH323Token (OOCTXT* pctxt, H225_SeqOfH225CryptoH323Token* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225CryptoH323Token (OOCTXT* pctxt, H225_SeqOfH225CryptoH323Token* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_fastStart                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Setup_UUIE_fastStart {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225Setup_UUIE_fastStart;
+
+EXTERN int asn1PE_H225Setup_UUIE_fastStart (OOCTXT* pctxt, H225Setup_UUIE_fastStart* pvalue);
+
+EXTERN int asn1PD_H225Setup_UUIE_fastStart (OOCTXT* pctxt, H225Setup_UUIE_fastStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ScnConnectionType                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225ScnConnectionType_unknown 1
+#define T_H225ScnConnectionType_bChannel 2
+#define T_H225ScnConnectionType_hybrid2x64 3
+#define T_H225ScnConnectionType_hybrid384 4
+#define T_H225ScnConnectionType_hybrid1536 5
+#define T_H225ScnConnectionType_hybrid1920 6
+#define T_H225ScnConnectionType_multirate 7
+#define T_H225ScnConnectionType_extElem1 8
+
+typedef struct EXTERN H225ScnConnectionType {
+   int t;
+} H225ScnConnectionType;
+
+EXTERN int asn1PE_H225ScnConnectionType (OOCTXT* pctxt, H225ScnConnectionType* pvalue);
+
+EXTERN int asn1PD_H225ScnConnectionType (OOCTXT* pctxt, H225ScnConnectionType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ScnConnectionAggregation                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225ScnConnectionAggregation_auto_ 1
+#define T_H225ScnConnectionAggregation_none 2
+#define T_H225ScnConnectionAggregation_h221 3
+#define T_H225ScnConnectionAggregation_bonded_mode1 4
+#define T_H225ScnConnectionAggregation_bonded_mode2 5
+#define T_H225ScnConnectionAggregation_bonded_mode3 6
+#define T_H225ScnConnectionAggregation_extElem1 7
+
+typedef struct EXTERN H225ScnConnectionAggregation {
+   int t;
+} H225ScnConnectionAggregation;
+
+EXTERN int asn1PE_H225ScnConnectionAggregation (OOCTXT* pctxt, H225ScnConnectionAggregation* pvalue);
+
+EXTERN int asn1PD_H225ScnConnectionAggregation (OOCTXT* pctxt, H225ScnConnectionAggregation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_connectionParameters                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Setup_UUIE_connectionParameters {
+   H225ScnConnectionType connectionType;
+   ASN1USINT numberOfScnConnections;
+   H225ScnConnectionAggregation connectionAggregation;
+} H225Setup_UUIE_connectionParameters;
+
+EXTERN int asn1PE_H225Setup_UUIE_connectionParameters (OOCTXT* pctxt, H225Setup_UUIE_connectionParameters* pvalue);
+
+EXTERN int asn1PD_H225Setup_UUIE_connectionParameters (OOCTXT* pctxt, H225Setup_UUIE_connectionParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_language                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Setup_UUIE_language {
+   ASN1UINT n;
+   ASN1IA5String *elem;
+} H225Setup_UUIE_language;
+
+EXTERN int asn1PE_H225Setup_UUIE_language (OOCTXT* pctxt, H225Setup_UUIE_language* pvalue);
+
+EXTERN int asn1PD_H225Setup_UUIE_language (OOCTXT* pctxt, H225Setup_UUIE_language* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  PresentationIndicator                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225PresentationIndicator_presentationAllowed 1
+#define T_H225PresentationIndicator_presentationRestricted 2
+#define T_H225PresentationIndicator_addressNotAvailable 3
+#define T_H225PresentationIndicator_extElem1 4
+
+typedef struct EXTERN H225PresentationIndicator {
+   int t;
+} H225PresentationIndicator;
+
+EXTERN int asn1PE_H225PresentationIndicator (OOCTXT* pctxt, H225PresentationIndicator* pvalue);
+
+EXTERN int asn1PD_H225PresentationIndicator (OOCTXT* pctxt, H225PresentationIndicator* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl_billingMode                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225CallCreditServiceControl_billingMode_credit 1
+#define T_H225CallCreditServiceControl_billingMode_debit 2
+#define T_H225CallCreditServiceControl_billingMode_extElem1 3
+
+typedef struct EXTERN H225CallCreditServiceControl_billingMode {
+   int t;
+} H225CallCreditServiceControl_billingMode;
+
+EXTERN int asn1PE_H225CallCreditServiceControl_billingMode (OOCTXT* pctxt, H225CallCreditServiceControl_billingMode* pvalue);
+
+EXTERN int asn1PD_H225CallCreditServiceControl_billingMode (OOCTXT* pctxt, H225CallCreditServiceControl_billingMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl_callStartingPoint                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225CallCreditServiceControl_callStartingPoint_alerting 1
+#define T_H225CallCreditServiceControl_callStartingPoint_connect 2
+#define T_H225CallCreditServiceControl_callStartingPoint_extElem1 3
+
+typedef struct EXTERN H225CallCreditServiceControl_callStartingPoint {
+   int t;
+} H225CallCreditServiceControl_callStartingPoint;
+
+EXTERN int asn1PE_H225CallCreditServiceControl_callStartingPoint (OOCTXT* pctxt, H225CallCreditServiceControl_callStartingPoint* pvalue);
+
+EXTERN int asn1PD_H225CallCreditServiceControl_callStartingPoint (OOCTXT* pctxt, H225CallCreditServiceControl_callStartingPoint* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallCreditServiceControl {
+   struct {
+      unsigned amountStringPresent : 1;
+      unsigned billingModePresent : 1;
+      unsigned callDurationLimitPresent : 1;
+      unsigned enforceCallDurationLimitPresent : 1;
+      unsigned callStartingPointPresent : 1;
+   } m;
+   ASN1BMPString amountString;
+   H225CallCreditServiceControl_billingMode billingMode;
+   ASN1UINT callDurationLimit;
+   ASN1BOOL enforceCallDurationLimit;
+   H225CallCreditServiceControl_callStartingPoint callStartingPoint;
+} H225CallCreditServiceControl;
+
+EXTERN int asn1PE_H225CallCreditServiceControl (OOCTXT* pctxt, H225CallCreditServiceControl* pvalue);
+
+EXTERN int asn1PD_H225CallCreditServiceControl (OOCTXT* pctxt, H225CallCreditServiceControl* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlDescriptor                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225ServiceControlDescriptor_url 1
+#define T_H225ServiceControlDescriptor_signal 2
+#define T_H225ServiceControlDescriptor_nonStandard 3
+#define T_H225ServiceControlDescriptor_callCreditServiceControl 4
+#define T_H225ServiceControlDescriptor_extElem1 5
+
+typedef struct EXTERN H225ServiceControlDescriptor {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1IA5String url;
+      /* t = 2 */
+      H225H248SignalsDescriptor *signal;
+      /* t = 3 */
+      H225NonStandardParameter *nonStandard;
+      /* t = 4 */
+      H225CallCreditServiceControl *callCreditServiceControl;
+      /* t = 5 */
+   } u;
+} H225ServiceControlDescriptor;
+
+EXTERN int asn1PE_H225ServiceControlDescriptor (OOCTXT* pctxt, H225ServiceControlDescriptor* pvalue);
+
+EXTERN int asn1PD_H225ServiceControlDescriptor (OOCTXT* pctxt, H225ServiceControlDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlSession_reason                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225ServiceControlSession_reason_open 1
+#define T_H225ServiceControlSession_reason_refresh 2
+#define T_H225ServiceControlSession_reason_close 3
+#define T_H225ServiceControlSession_reason_extElem1 4
+
+typedef struct EXTERN H225ServiceControlSession_reason {
+   int t;
+} H225ServiceControlSession_reason;
+
+EXTERN int asn1PE_H225ServiceControlSession_reason (OOCTXT* pctxt, H225ServiceControlSession_reason* pvalue);
+
+EXTERN int asn1PD_H225ServiceControlSession_reason (OOCTXT* pctxt, H225ServiceControlSession_reason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlSession                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ServiceControlSession {
+   struct {
+      unsigned contentsPresent : 1;
+   } m;
+   ASN1UINT8 sessionId;
+   H225ServiceControlDescriptor contents;
+   H225ServiceControlSession_reason reason;
+} H225ServiceControlSession;
+
+EXTERN int asn1PE_H225ServiceControlSession (OOCTXT* pctxt, H225ServiceControlSession* pvalue);
+
+EXTERN int asn1PD_H225ServiceControlSession (OOCTXT* pctxt, H225ServiceControlSession* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ServiceControlSession                           */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225ServiceControlSession */
+typedef DList H225_SeqOfH225ServiceControlSession;
+
+EXTERN int asn1PE_H225_SeqOfH225ServiceControlSession (OOCTXT* pctxt, H225_SeqOfH225ServiceControlSession* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225ServiceControlSession (OOCTXT* pctxt, H225_SeqOfH225ServiceControlSession* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CarrierInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CarrierInfo {
+   struct {
+      unsigned carrierIdentificationCodePresent : 1;
+      unsigned carrierNamePresent : 1;
+   } m;
+   H225CarrierInfo_carrierIdentificationCode carrierIdentificationCode;
+   ASN1IA5String carrierName;
+} H225CarrierInfo;
+
+EXTERN int asn1PE_H225CarrierInfo (OOCTXT* pctxt, H225CarrierInfo* pvalue);
+
+EXTERN int asn1PD_H225CarrierInfo (OOCTXT* pctxt, H225CarrierInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallsAvailable                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallsAvailable {
+   struct {
+      unsigned groupPresent : 1;
+      unsigned carrierPresent : 1;
+   } m;
+   ASN1UINT calls;
+   ASN1IA5String group;
+   H225CarrierInfo carrier;
+} H225CallsAvailable;
+
+EXTERN int asn1PE_H225CallsAvailable (OOCTXT* pctxt, H225CallsAvailable* pvalue);
+
+EXTERN int asn1PD_H225CallsAvailable (OOCTXT* pctxt, H225CallsAvailable* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CallsAvailable                                  */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225CallsAvailable */
+typedef DList H225_SeqOfH225CallsAvailable;
+
+EXTERN int asn1PE_H225_SeqOfH225CallsAvailable (OOCTXT* pctxt, H225_SeqOfH225CallsAvailable* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225CallsAvailable (OOCTXT* pctxt, H225_SeqOfH225CallsAvailable* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallCapacityInfo                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallCapacityInfo {
+   struct {
+      unsigned voiceGwCallsAvailablePresent : 1;
+      unsigned h310GwCallsAvailablePresent : 1;
+      unsigned h320GwCallsAvailablePresent : 1;
+      unsigned h321GwCallsAvailablePresent : 1;
+      unsigned h322GwCallsAvailablePresent : 1;
+      unsigned h323GwCallsAvailablePresent : 1;
+      unsigned h324GwCallsAvailablePresent : 1;
+      unsigned t120OnlyGwCallsAvailablePresent : 1;
+      unsigned t38FaxAnnexbOnlyGwCallsAvailablePresent : 1;
+      unsigned terminalCallsAvailablePresent : 1;
+      unsigned mcuCallsAvailablePresent : 1;
+      unsigned sipGwCallsAvailablePresent : 1;
+   } m;
+   H225_SeqOfH225CallsAvailable voiceGwCallsAvailable;
+   H225_SeqOfH225CallsAvailable h310GwCallsAvailable;
+   H225_SeqOfH225CallsAvailable h320GwCallsAvailable;
+   H225_SeqOfH225CallsAvailable h321GwCallsAvailable;
+   H225_SeqOfH225CallsAvailable h322GwCallsAvailable;
+   H225_SeqOfH225CallsAvailable h323GwCallsAvailable;
+   H225_SeqOfH225CallsAvailable h324GwCallsAvailable;
+   H225_SeqOfH225CallsAvailable t120OnlyGwCallsAvailable;
+   H225_SeqOfH225CallsAvailable t38FaxAnnexbOnlyGwCallsAvailable;
+   H225_SeqOfH225CallsAvailable terminalCallsAvailable;
+   H225_SeqOfH225CallsAvailable mcuCallsAvailable;
+   H225_SeqOfH225CallsAvailable sipGwCallsAvailable;
+} H225CallCapacityInfo;
+
+EXTERN int asn1PE_H225CallCapacityInfo (OOCTXT* pctxt, H225CallCapacityInfo* pvalue);
+
+EXTERN int asn1PD_H225CallCapacityInfo (OOCTXT* pctxt, H225CallCapacityInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallCapacity                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallCapacity {
+   struct {
+      unsigned maximumCallCapacityPresent : 1;
+      unsigned currentCallCapacityPresent : 1;
+   } m;
+   H225CallCapacityInfo maximumCallCapacity;
+   H225CallCapacityInfo currentCallCapacity;
+} H225CallCapacity;
+
+EXTERN int asn1PE_H225CallCapacity (OOCTXT* pctxt, H225CallCapacity* pvalue);
+
+EXTERN int asn1PD_H225CallCapacity (OOCTXT* pctxt, H225CallCapacity* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CicInfo_cic_element                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225_SeqOfH225CicInfo_cic_element {
+   ASN1UINT n;
+   H225CicInfo_cic_element *elem;
+} H225_SeqOfH225CicInfo_cic_element;
+
+EXTERN int asn1PE_H225_SeqOfH225CicInfo_cic_element (OOCTXT* pctxt, H225_SeqOfH225CicInfo_cic_element* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225CicInfo_cic_element (OOCTXT* pctxt, H225_SeqOfH225CicInfo_cic_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo                                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CicInfo {
+   H225_SeqOfH225CicInfo_cic_element cic;
+   H225CicInfo_pointCode pointCode;
+} H225CicInfo;
+
+EXTERN int asn1PE_H225CicInfo (OOCTXT* pctxt, H225CicInfo* pvalue);
+
+EXTERN int asn1PD_H225CicInfo (OOCTXT* pctxt, H225CicInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GroupID_member                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GroupID_member {
+   ASN1UINT n;
+   ASN1USINT *elem;
+} H225GroupID_member;
+
+EXTERN int asn1PE_H225GroupID_member (OOCTXT* pctxt, H225GroupID_member* pvalue);
+
+EXTERN int asn1PD_H225GroupID_member (OOCTXT* pctxt, H225GroupID_member* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GroupID                                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GroupID {
+   struct {
+      unsigned memberPresent : 1;
+   } m;
+   H225GroupID_member member;
+   ASN1IA5String group;
+} H225GroupID;
+
+EXTERN int asn1PE_H225GroupID (OOCTXT* pctxt, H225GroupID* pvalue);
+
+EXTERN int asn1PD_H225GroupID (OOCTXT* pctxt, H225GroupID* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CircuitIdentifier                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CircuitIdentifier {
+   struct {
+      unsigned cicPresent : 1;
+      unsigned groupPresent : 1;
+      unsigned carrierPresent : 1;
+   } m;
+   H225CicInfo cic;
+   H225GroupID group;
+   H225CarrierInfo carrier;
+} H225CircuitIdentifier;
+
+EXTERN int asn1PE_H225CircuitIdentifier (OOCTXT* pctxt, H225CircuitIdentifier* pvalue);
+
+EXTERN int asn1PD_H225CircuitIdentifier (OOCTXT* pctxt, H225CircuitIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225GenericData                                     */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225GenericData */
+typedef DList H225_SeqOfH225GenericData;
+
+EXTERN int asn1PE_H225_SeqOfH225GenericData (OOCTXT* pctxt, H225_SeqOfH225GenericData* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225GenericData (OOCTXT* pctxt, H225_SeqOfH225GenericData* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CircuitInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CircuitInfo {
+   struct {
+      unsigned sourceCircuitIDPresent : 1;
+      unsigned destinationCircuitIDPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225CircuitIdentifier sourceCircuitID;
+   H225CircuitIdentifier destinationCircuitID;
+   H225_SeqOfH225GenericData genericData;
+} H225CircuitInfo;
+
+EXTERN int asn1PE_H225CircuitInfo (OOCTXT* pctxt, H225CircuitInfo* pvalue);
+
+EXTERN int asn1PD_H225CircuitInfo (OOCTXT* pctxt, H225CircuitInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225FeatureDescriptor                               */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225FeatureDescriptor */
+typedef DList H225_SeqOfH225FeatureDescriptor;
+
+EXTERN int asn1PE_H225_SeqOfH225FeatureDescriptor (OOCTXT* pctxt, H225_SeqOfH225FeatureDescriptor* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225FeatureDescriptor (OOCTXT* pctxt, H225_SeqOfH225FeatureDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_parallelH245Control                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Setup_UUIE_parallelH245Control {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225Setup_UUIE_parallelH245Control;
+
+EXTERN int asn1PE_H225Setup_UUIE_parallelH245Control (OOCTXT* pctxt, H225Setup_UUIE_parallelH245Control* pvalue);
+
+EXTERN int asn1PD_H225Setup_UUIE_parallelH245Control (OOCTXT* pctxt, H225Setup_UUIE_parallelH245Control* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ExtendedAliasAddress                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ExtendedAliasAddress {
+   struct {
+      unsigned presentationIndicatorPresent : 1;
+      unsigned screeningIndicatorPresent : 1;
+   } m;
+   H225AliasAddress address;
+   H225PresentationIndicator presentationIndicator;
+   H225ScreeningIndicator screeningIndicator;
+} H225ExtendedAliasAddress;
+
+EXTERN int asn1PE_H225ExtendedAliasAddress (OOCTXT* pctxt, H225ExtendedAliasAddress* pvalue);
+
+EXTERN int asn1PD_H225ExtendedAliasAddress (OOCTXT* pctxt, H225ExtendedAliasAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ExtendedAliasAddress                            */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225ExtendedAliasAddress */
+typedef DList H225_SeqOfH225ExtendedAliasAddress;
+
+EXTERN int asn1PE_H225_SeqOfH225ExtendedAliasAddress (OOCTXT* pctxt, H225_SeqOfH225ExtendedAliasAddress* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225ExtendedAliasAddress (OOCTXT* pctxt, H225_SeqOfH225ExtendedAliasAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE                                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Setup_UUIE {
+   struct {
+      unsigned h245AddressPresent : 1;
+      unsigned sourceAddressPresent : 1;
+      unsigned destinationAddressPresent : 1;
+      unsigned destCallSignalAddressPresent : 1;
+      unsigned destExtraCallInfoPresent : 1;
+      unsigned destExtraCRVPresent : 1;
+      unsigned callServicesPresent : 1;
+      unsigned sourceCallSignalAddressPresent : 1;
+      unsigned remoteExtensionAddressPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned h245SecurityCapabilityPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned fastStartPresent : 1;
+      unsigned mediaWaitForConnectPresent : 1;
+      unsigned canOverlapSendPresent : 1;
+      unsigned endpointIdentifierPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned maintainConnectionPresent : 1;
+      unsigned connectionParametersPresent : 1;
+      unsigned languagePresent : 1;
+      unsigned presentationIndicatorPresent : 1;
+      unsigned screeningIndicatorPresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned symmetricOperationRequiredPresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned desiredProtocolsPresent : 1;
+      unsigned neededFeaturesPresent : 1;
+      unsigned desiredFeaturesPresent : 1;
+      unsigned supportedFeaturesPresent : 1;
+      unsigned parallelH245ControlPresent : 1;
+      unsigned additionalSourceAddressesPresent : 1;
+      unsigned hopCountPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225TransportAddress h245Address;
+   H225_SeqOfH225AliasAddress sourceAddress;
+   H225EndpointType sourceInfo;
+   H225_SeqOfH225AliasAddress destinationAddress;
+   H225TransportAddress destCallSignalAddress;
+   H225_SeqOfH225AliasAddress destExtraCallInfo;
+   H225_SeqOfH225CallReferenceValue destExtraCRV;
+   ASN1BOOL activeMC;
+   H225ConferenceIdentifier conferenceID;
+   H225Setup_UUIE_conferenceGoal conferenceGoal;
+   H225QseriesOptions callServices;
+   H225CallType callType;
+   H225TransportAddress sourceCallSignalAddress;
+   H225AliasAddress remoteExtensionAddress;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225H245Security h245SecurityCapability;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225Setup_UUIE_fastStart fastStart;
+   ASN1BOOL mediaWaitForConnect;
+   ASN1BOOL canOverlapSend;
+   H225EndpointIdentifier endpointIdentifier;
+   ASN1BOOL multipleCalls;
+   ASN1BOOL maintainConnection;
+   H225Setup_UUIE_connectionParameters connectionParameters;
+   H225Setup_UUIE_language language;
+   H225PresentationIndicator presentationIndicator;
+   H225ScreeningIndicator screeningIndicator;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225CallCapacity capacity;
+   H225CircuitInfo circuitInfo;
+   H225_SeqOfH225SupportedProtocols desiredProtocols;
+   H225_SeqOfH225FeatureDescriptor neededFeatures;
+   H225_SeqOfH225FeatureDescriptor desiredFeatures;
+   H225_SeqOfH225FeatureDescriptor supportedFeatures;
+   H225Setup_UUIE_parallelH245Control parallelH245Control;
+   H225_SeqOfH225ExtendedAliasAddress additionalSourceAddresses;
+   ASN1UINT8 hopCount;
+} H225Setup_UUIE;
+
+EXTERN int asn1PE_H225Setup_UUIE (OOCTXT* pctxt, H225Setup_UUIE* pvalue);
+
+EXTERN int asn1PD_H225Setup_UUIE (OOCTXT* pctxt, H225Setup_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallProceeding_UUIE_fastStart                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallProceeding_UUIE_fastStart {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225CallProceeding_UUIE_fastStart;
+
+EXTERN int asn1PE_H225CallProceeding_UUIE_fastStart (OOCTXT* pctxt, H225CallProceeding_UUIE_fastStart* pvalue);
+
+EXTERN int asn1PD_H225CallProceeding_UUIE_fastStart (OOCTXT* pctxt, H225CallProceeding_UUIE_fastStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FeatureSet                                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225FeatureSet {
+   struct {
+      unsigned neededFeaturesPresent : 1;
+      unsigned desiredFeaturesPresent : 1;
+      unsigned supportedFeaturesPresent : 1;
+   } m;
+   ASN1BOOL replacementFeatureSet;
+   H225_SeqOfH225FeatureDescriptor neededFeatures;
+   H225_SeqOfH225FeatureDescriptor desiredFeatures;
+   H225_SeqOfH225FeatureDescriptor supportedFeatures;
+} H225FeatureSet;
+
+EXTERN int asn1PE_H225FeatureSet (OOCTXT* pctxt, H225FeatureSet* pvalue);
+
+EXTERN int asn1PD_H225FeatureSet (OOCTXT* pctxt, H225FeatureSet* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallProceeding_UUIE                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallProceeding_UUIE {
+   struct {
+      unsigned h245AddressPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned h245SecurityModePresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned fastStartPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned maintainConnectionPresent : 1;
+      unsigned fastConnectRefusedPresent : 1;
+      unsigned featureSetPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225EndpointType destinationInfo;
+   H225TransportAddress h245Address;
+   H225CallIdentifier callIdentifier;
+   H225H245Security h245SecurityMode;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225CallProceeding_UUIE_fastStart fastStart;
+   ASN1BOOL multipleCalls;
+   ASN1BOOL maintainConnection;
+   H225FeatureSet featureSet;
+} H225CallProceeding_UUIE;
+
+EXTERN int asn1PE_H225CallProceeding_UUIE (OOCTXT* pctxt, H225CallProceeding_UUIE* pvalue);
+
+EXTERN int asn1PD_H225CallProceeding_UUIE (OOCTXT* pctxt, H225CallProceeding_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE_fastStart                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Connect_UUIE_fastStart {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225Connect_UUIE_fastStart;
+
+EXTERN int asn1PE_H225Connect_UUIE_fastStart (OOCTXT* pctxt, H225Connect_UUIE_fastStart* pvalue);
+
+EXTERN int asn1PD_H225Connect_UUIE_fastStart (OOCTXT* pctxt, H225Connect_UUIE_fastStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE_language                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Connect_UUIE_language {
+   ASN1UINT n;
+   ASN1IA5String *elem;
+} H225Connect_UUIE_language;
+
+EXTERN int asn1PE_H225Connect_UUIE_language (OOCTXT* pctxt, H225Connect_UUIE_language* pvalue);
+
+EXTERN int asn1PD_H225Connect_UUIE_language (OOCTXT* pctxt, H225Connect_UUIE_language* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Connect_UUIE {
+   struct {
+      unsigned h245AddressPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned h245SecurityModePresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned fastStartPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned maintainConnectionPresent : 1;
+      unsigned languagePresent : 1;
+      unsigned connectedAddressPresent : 1;
+      unsigned presentationIndicatorPresent : 1;
+      unsigned screeningIndicatorPresent : 1;
+      unsigned fastConnectRefusedPresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned featureSetPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225TransportAddress h245Address;
+   H225EndpointType destinationInfo;
+   H225ConferenceIdentifier conferenceID;
+   H225CallIdentifier callIdentifier;
+   H225H245Security h245SecurityMode;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225Connect_UUIE_fastStart fastStart;
+   ASN1BOOL multipleCalls;
+   ASN1BOOL maintainConnection;
+   H225Connect_UUIE_language language;
+   H225_SeqOfH225AliasAddress connectedAddress;
+   H225PresentationIndicator presentationIndicator;
+   H225ScreeningIndicator screeningIndicator;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225CallCapacity capacity;
+   H225FeatureSet featureSet;
+} H225Connect_UUIE;
+
+EXTERN int asn1PE_H225Connect_UUIE (OOCTXT* pctxt, H225Connect_UUIE* pvalue);
+
+EXTERN int asn1PD_H225Connect_UUIE (OOCTXT* pctxt, H225Connect_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Alerting_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Alerting_UUIE_fastStart {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225Alerting_UUIE_fastStart;
+
+EXTERN int asn1PE_H225Alerting_UUIE_fastStart (OOCTXT* pctxt, H225Alerting_UUIE_fastStart* pvalue);
+
+EXTERN int asn1PD_H225Alerting_UUIE_fastStart (OOCTXT* pctxt, H225Alerting_UUIE_fastStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Alerting_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Alerting_UUIE {
+   struct {
+      unsigned h245AddressPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned h245SecurityModePresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned fastStartPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned maintainConnectionPresent : 1;
+      unsigned alertingAddressPresent : 1;
+      unsigned presentationIndicatorPresent : 1;
+      unsigned screeningIndicatorPresent : 1;
+      unsigned fastConnectRefusedPresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned featureSetPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225EndpointType destinationInfo;
+   H225TransportAddress h245Address;
+   H225CallIdentifier callIdentifier;
+   H225H245Security h245SecurityMode;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225Alerting_UUIE_fastStart fastStart;
+   ASN1BOOL multipleCalls;
+   ASN1BOOL maintainConnection;
+   H225_SeqOfH225AliasAddress alertingAddress;
+   H225PresentationIndicator presentationIndicator;
+   H225ScreeningIndicator screeningIndicator;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225CallCapacity capacity;
+   H225FeatureSet featureSet;
+} H225Alerting_UUIE;
+
+EXTERN int asn1PE_H225Alerting_UUIE (OOCTXT* pctxt, H225Alerting_UUIE* pvalue);
+
+EXTERN int asn1PD_H225Alerting_UUIE (OOCTXT* pctxt, H225Alerting_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Information_UUIE_fastStart                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Information_UUIE_fastStart {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225Information_UUIE_fastStart;
+
+EXTERN int asn1PE_H225Information_UUIE_fastStart (OOCTXT* pctxt, H225Information_UUIE_fastStart* pvalue);
+
+EXTERN int asn1PD_H225Information_UUIE_fastStart (OOCTXT* pctxt, H225Information_UUIE_fastStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Information_UUIE                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Information_UUIE {
+   struct {
+      unsigned callIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned fastStartPresent : 1;
+      unsigned fastConnectRefusedPresent : 1;
+      unsigned circuitInfoPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225Information_UUIE_fastStart fastStart;
+   H225CircuitInfo circuitInfo;
+} H225Information_UUIE;
+
+EXTERN int asn1PE_H225Information_UUIE (OOCTXT* pctxt, H225Information_UUIE* pvalue);
+
+EXTERN int asn1PD_H225Information_UUIE (OOCTXT* pctxt, H225Information_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityErrors                                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225SecurityErrors_securityWrongSyncTime 1
+#define T_H225SecurityErrors_securityReplay 2
+#define T_H225SecurityErrors_securityWrongGeneralID 3
+#define T_H225SecurityErrors_securityWrongSendersID 4
+#define T_H225SecurityErrors_securityIntegrityFailed 5
+#define T_H225SecurityErrors_securityWrongOID 6
+#define T_H225SecurityErrors_securityDHmismatch 7
+#define T_H225SecurityErrors_securityCertificateExpired 8
+#define T_H225SecurityErrors_securityCertificateDateInvalid 9
+#define T_H225SecurityErrors_securityCertificateRevoked 10
+#define T_H225SecurityErrors_securityCertificateNotReadable 11
+#define T_H225SecurityErrors_securityCertificateSignatureInvalid 12
+#define T_H225SecurityErrors_securityCertificateMissing 13
+#define T_H225SecurityErrors_securityCertificateIncomplete 14
+#define T_H225SecurityErrors_securityUnsupportedCertificateAlgOID 15
+#define T_H225SecurityErrors_securityUnknownCA 16
+#define T_H225SecurityErrors_extElem1   17
+
+typedef struct EXTERN H225SecurityErrors {
+   int t;
+} H225SecurityErrors;
+
+EXTERN int asn1PE_H225SecurityErrors (OOCTXT* pctxt, H225SecurityErrors* pvalue);
+
+EXTERN int asn1PD_H225SecurityErrors (OOCTXT* pctxt, H225SecurityErrors* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ReleaseCompleteReason                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225ReleaseCompleteReason_noBandwidth 1
+#define T_H225ReleaseCompleteReason_gatekeeperResources 2
+#define T_H225ReleaseCompleteReason_unreachableDestination 3
+#define T_H225ReleaseCompleteReason_destinationRejection 4
+#define T_H225ReleaseCompleteReason_invalidRevision 5
+#define T_H225ReleaseCompleteReason_noPermission 6
+#define T_H225ReleaseCompleteReason_unreachableGatekeeper 7
+#define T_H225ReleaseCompleteReason_gatewayResources 8
+#define T_H225ReleaseCompleteReason_badFormatAddress 9
+#define T_H225ReleaseCompleteReason_adaptiveBusy 10
+#define T_H225ReleaseCompleteReason_inConf 11
+#define T_H225ReleaseCompleteReason_undefinedReason 12
+#define T_H225ReleaseCompleteReason_facilityCallDeflection 13
+#define T_H225ReleaseCompleteReason_securityDenied 14
+#define T_H225ReleaseCompleteReason_calledPartyNotRegistered 15
+#define T_H225ReleaseCompleteReason_callerNotRegistered 16
+#define T_H225ReleaseCompleteReason_newConnectionNeeded 17
+#define T_H225ReleaseCompleteReason_nonStandardReason 18
+#define T_H225ReleaseCompleteReason_replaceWithConferenceInvite 19
+#define T_H225ReleaseCompleteReason_genericDataReason 20
+#define T_H225ReleaseCompleteReason_neededFeatureNotSupported 21
+#define T_H225ReleaseCompleteReason_tunnelledSignallingRejected 22
+#define T_H225ReleaseCompleteReason_invalidCID 23
+#define T_H225ReleaseCompleteReason_securityError 24
+#define T_H225ReleaseCompleteReason_hopCountExceeded 25
+#define T_H225ReleaseCompleteReason_extElem1 26
+
+typedef struct EXTERN H225ReleaseCompleteReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      /* t = 9 */
+      /* t = 10 */
+      /* t = 11 */
+      /* t = 12 */
+      /* t = 13 */
+      /* t = 14 */
+      /* t = 15 */
+      /* t = 16 */
+      /* t = 17 */
+      /* t = 18 */
+      H225NonStandardParameter *nonStandardReason;
+      /* t = 19 */
+      H225ConferenceIdentifier *replaceWithConferenceInvite;
+      /* t = 20 */
+      /* t = 21 */
+      /* t = 22 */
+      /* t = 23 */
+      /* t = 24 */
+      H225SecurityErrors *securityError;
+      /* t = 25 */
+      /* t = 26 */
+   } u;
+} H225ReleaseCompleteReason;
+
+EXTERN int asn1PE_H225ReleaseCompleteReason (OOCTXT* pctxt, H225ReleaseCompleteReason* pvalue);
+
+EXTERN int asn1PD_H225ReleaseCompleteReason (OOCTXT* pctxt, H225ReleaseCompleteReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ReleaseComplete_UUIE                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ReleaseComplete_UUIE {
+   struct {
+      unsigned reasonPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned busyAddressPresent : 1;
+      unsigned presentationIndicatorPresent : 1;
+      unsigned screeningIndicatorPresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned featureSetPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225ReleaseCompleteReason reason;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225_SeqOfH225AliasAddress busyAddress;
+   H225PresentationIndicator presentationIndicator;
+   H225ScreeningIndicator screeningIndicator;
+   H225CallCapacity capacity;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225FeatureSet featureSet;
+} H225ReleaseComplete_UUIE;
+
+EXTERN int asn1PE_H225ReleaseComplete_UUIE (OOCTXT* pctxt, H225ReleaseComplete_UUIE* pvalue);
+
+EXTERN int asn1PD_H225ReleaseComplete_UUIE (OOCTXT* pctxt, H225ReleaseComplete_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FacilityReason                                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225FacilityReason_routeCallToGatekeeper 1
+#define T_H225FacilityReason_callForwarded 2
+#define T_H225FacilityReason_routeCallToMC 3
+#define T_H225FacilityReason_undefinedReason 4
+#define T_H225FacilityReason_conferenceListChoice 5
+#define T_H225FacilityReason_startH245  6
+#define T_H225FacilityReason_noH245     7
+#define T_H225FacilityReason_newTokens  8
+#define T_H225FacilityReason_featureSetUpdate 9
+#define T_H225FacilityReason_forwardedElements 10
+#define T_H225FacilityReason_transportedInformation 11
+#define T_H225FacilityReason_extElem1   12
+
+typedef struct EXTERN H225FacilityReason {
+   int t;
+} H225FacilityReason;
+
+EXTERN int asn1PE_H225FacilityReason (OOCTXT* pctxt, H225FacilityReason* pvalue);
+
+EXTERN int asn1PD_H225FacilityReason (OOCTXT* pctxt, H225FacilityReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceList                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ConferenceList {
+   struct {
+      unsigned conferenceIDPresent : 1;
+      unsigned conferenceAliasPresent : 1;
+      unsigned nonStandardDataPresent : 1;
+   } m;
+   H225ConferenceIdentifier conferenceID;
+   H225AliasAddress conferenceAlias;
+   H225NonStandardParameter nonStandardData;
+} H225ConferenceList;
+
+EXTERN int asn1PE_H225ConferenceList (OOCTXT* pctxt, H225ConferenceList* pvalue);
+
+EXTERN int asn1PD_H225ConferenceList (OOCTXT* pctxt, H225ConferenceList* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ConferenceList                                  */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225ConferenceList */
+typedef DList H225_SeqOfH225ConferenceList;
+
+EXTERN int asn1PE_H225_SeqOfH225ConferenceList (OOCTXT* pctxt, H225_SeqOfH225ConferenceList* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225ConferenceList (OOCTXT* pctxt, H225_SeqOfH225ConferenceList* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Facility_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Facility_UUIE_fastStart {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225Facility_UUIE_fastStart;
+
+EXTERN int asn1PE_H225Facility_UUIE_fastStart (OOCTXT* pctxt, H225Facility_UUIE_fastStart* pvalue);
+
+EXTERN int asn1PD_H225Facility_UUIE_fastStart (OOCTXT* pctxt, H225Facility_UUIE_fastStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Facility_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Facility_UUIE {
+   struct {
+      unsigned alternativeAddressPresent : 1;
+      unsigned alternativeAliasAddressPresent : 1;
+      unsigned conferenceIDPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned destExtraCallInfoPresent : 1;
+      unsigned remoteExtensionAddressPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned conferencesPresent : 1;
+      unsigned h245AddressPresent : 1;
+      unsigned fastStartPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned maintainConnectionPresent : 1;
+      unsigned fastConnectRefusedPresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned destinationInfoPresent : 1;
+      unsigned h245SecurityModePresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225TransportAddress alternativeAddress;
+   H225_SeqOfH225AliasAddress alternativeAliasAddress;
+   H225ConferenceIdentifier conferenceID;
+   H225FacilityReason reason;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225AliasAddress destExtraCallInfo;
+   H225AliasAddress remoteExtensionAddress;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225_SeqOfH225ConferenceList conferences;
+   H225TransportAddress h245Address;
+   H225Facility_UUIE_fastStart fastStart;
+   ASN1BOOL multipleCalls;
+   ASN1BOOL maintainConnection;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225CircuitInfo circuitInfo;
+   H225FeatureSet featureSet;
+   H225EndpointType destinationInfo;
+   H225H245Security h245SecurityMode;
+} H225Facility_UUIE;
+
+EXTERN int asn1PE_H225Facility_UUIE (OOCTXT* pctxt, H225Facility_UUIE* pvalue);
+
+EXTERN int asn1PD_H225Facility_UUIE (OOCTXT* pctxt, H225Facility_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Progress_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Progress_UUIE_fastStart {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225Progress_UUIE_fastStart;
+
+EXTERN int asn1PE_H225Progress_UUIE_fastStart (OOCTXT* pctxt, H225Progress_UUIE_fastStart* pvalue);
+
+EXTERN int asn1PD_H225Progress_UUIE_fastStart (OOCTXT* pctxt, H225Progress_UUIE_fastStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Progress_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Progress_UUIE {
+   struct {
+      unsigned h245AddressPresent : 1;
+      unsigned h245SecurityModePresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned fastStartPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned maintainConnectionPresent : 1;
+      unsigned fastConnectRefusedPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225EndpointType destinationInfo;
+   H225TransportAddress h245Address;
+   H225CallIdentifier callIdentifier;
+   H225H245Security h245SecurityMode;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225Progress_UUIE_fastStart fastStart;
+   ASN1BOOL multipleCalls;
+   ASN1BOOL maintainConnection;
+} H225Progress_UUIE;
+
+EXTERN int asn1PE_H225Progress_UUIE (OOCTXT* pctxt, H225Progress_UUIE* pvalue);
+
+EXTERN int asn1PD_H225Progress_UUIE (OOCTXT* pctxt, H225Progress_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Status_UUIE                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Status_UUIE {
+   struct {
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+} H225Status_UUIE;
+
+EXTERN int asn1PE_H225Status_UUIE (OOCTXT* pctxt, H225Status_UUIE* pvalue);
+
+EXTERN int asn1PD_H225Status_UUIE (OOCTXT* pctxt, H225Status_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  StatusInquiry_UUIE                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225StatusInquiry_UUIE {
+   struct {
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+} H225StatusInquiry_UUIE;
+
+EXTERN int asn1PE_H225StatusInquiry_UUIE (OOCTXT* pctxt, H225StatusInquiry_UUIE* pvalue);
+
+EXTERN int asn1PD_H225StatusInquiry_UUIE (OOCTXT* pctxt, H225StatusInquiry_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SetupAcknowledge_UUIE                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225SetupAcknowledge_UUIE {
+   struct {
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+} H225SetupAcknowledge_UUIE;
+
+EXTERN int asn1PE_H225SetupAcknowledge_UUIE (OOCTXT* pctxt, H225SetupAcknowledge_UUIE* pvalue);
+
+EXTERN int asn1PD_H225SetupAcknowledge_UUIE (OOCTXT* pctxt, H225SetupAcknowledge_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Notify_UUIE                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Notify_UUIE {
+   struct {
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+   } m;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+} H225Notify_UUIE;
+
+EXTERN int asn1PE_H225Notify_UUIE (OOCTXT* pctxt, H225Notify_UUIE* pvalue);
+
+EXTERN int asn1PD_H225Notify_UUIE (OOCTXT* pctxt, H225Notify_UUIE* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h323_message_body                             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225H323_UU_PDU_h323_message_body_setup 1
+#define T_H225H323_UU_PDU_h323_message_body_callProceeding 2
+#define T_H225H323_UU_PDU_h323_message_body_connect 3
+#define T_H225H323_UU_PDU_h323_message_body_alerting 4
+#define T_H225H323_UU_PDU_h323_message_body_information 5
+#define T_H225H323_UU_PDU_h323_message_body_releaseComplete 6
+#define T_H225H323_UU_PDU_h323_message_body_facility 7
+#define T_H225H323_UU_PDU_h323_message_body_progress 8
+#define T_H225H323_UU_PDU_h323_message_body_empty 9
+#define T_H225H323_UU_PDU_h323_message_body_status 10
+#define T_H225H323_UU_PDU_h323_message_body_statusInquiry 11
+#define T_H225H323_UU_PDU_h323_message_body_setupAcknowledge 12
+#define T_H225H323_UU_PDU_h323_message_body_notify 13
+#define T_H225H323_UU_PDU_h323_message_body_extElem1 14
+
+typedef struct EXTERN H225H323_UU_PDU_h323_message_body {
+   int t;
+   union {
+      /* t = 1 */
+      H225Setup_UUIE *setup;
+      /* t = 2 */
+      H225CallProceeding_UUIE *callProceeding;
+      /* t = 3 */
+      H225Connect_UUIE *connect;
+      /* t = 4 */
+      H225Alerting_UUIE *alerting;
+      /* t = 5 */
+      H225Information_UUIE *information;
+      /* t = 6 */
+      H225ReleaseComplete_UUIE *releaseComplete;
+      /* t = 7 */
+      H225Facility_UUIE *facility;
+      /* t = 8 */
+      H225Progress_UUIE *progress;
+      /* t = 9 */
+      /* t = 10 */
+      H225Status_UUIE *status;
+      /* t = 11 */
+      H225StatusInquiry_UUIE *statusInquiry;
+      /* t = 12 */
+      H225SetupAcknowledge_UUIE *setupAcknowledge;
+      /* t = 13 */
+      H225Notify_UUIE *notify;
+      /* t = 14 */
+   } u;
+} H225H323_UU_PDU_h323_message_body;
+
+EXTERN int asn1PE_H225H323_UU_PDU_h323_message_body (OOCTXT* pctxt, H225H323_UU_PDU_h323_message_body* pvalue);
+
+EXTERN int asn1PD_H225H323_UU_PDU_h323_message_body (OOCTXT* pctxt, H225H323_UU_PDU_h323_message_body* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h4501SupplementaryService                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323_UU_PDU_h4501SupplementaryService {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225H323_UU_PDU_h4501SupplementaryService;
+
+EXTERN int asn1PE_H225H323_UU_PDU_h4501SupplementaryService (OOCTXT* pctxt, H225H323_UU_PDU_h4501SupplementaryService* pvalue);
+
+EXTERN int asn1PD_H225H323_UU_PDU_h4501SupplementaryService (OOCTXT* pctxt, H225H323_UU_PDU_h4501SupplementaryService* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h245Control                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323_UU_PDU_h245Control {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225H323_UU_PDU_h245Control;
+
+EXTERN int asn1PE_H225H323_UU_PDU_h245Control (OOCTXT* pctxt, H225H323_UU_PDU_h245Control* pvalue);
+
+EXTERN int asn1PD_H225H323_UU_PDU_h245Control (OOCTXT* pctxt, H225H323_UU_PDU_h245Control* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225NonStandardParameter                            */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225NonStandardParameter */
+typedef DList H225_SeqOfH225NonStandardParameter;
+
+EXTERN int asn1PE_H225_SeqOfH225NonStandardParameter (OOCTXT* pctxt, H225_SeqOfH225NonStandardParameter* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225NonStandardParameter (OOCTXT* pctxt, H225_SeqOfH225NonStandardParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallLinkage                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallLinkage {
+   struct {
+      unsigned globalCallIdPresent : 1;
+      unsigned threadIdPresent : 1;
+   } m;
+   H225GloballyUniqueID globalCallId;
+   H225GloballyUniqueID threadId;
+} H225CallLinkage;
+
+EXTERN int asn1PE_H225CallLinkage (OOCTXT* pctxt, H225CallLinkage* pvalue);
+
+EXTERN int asn1PD_H225CallLinkage (OOCTXT* pctxt, H225CallLinkage* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_tunnelledSignallingMessage_messageContent     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323_UU_PDU_tunnelledSignallingMessage_messageContent {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} H225H323_UU_PDU_tunnelledSignallingMessage_messageContent;
+
+EXTERN int asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage_messageContent* pvalue);
+
+EXTERN int asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage_messageContent* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_tunnelledSignallingMessage                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323_UU_PDU_tunnelledSignallingMessage {
+   struct {
+      unsigned tunnellingRequiredPresent : 1;
+      unsigned nonStandardDataPresent : 1;
+   } m;
+   H225TunnelledProtocol tunnelledProtocolID;
+   H225H323_UU_PDU_tunnelledSignallingMessage_messageContent messageContent;
+   H225NonStandardParameter nonStandardData;
+} H225H323_UU_PDU_tunnelledSignallingMessage;
+
+EXTERN int asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage* pvalue);
+
+EXTERN int asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  StimulusControl                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225StimulusControl {
+   struct {
+      unsigned nonStandardPresent : 1;
+      unsigned isTextPresent : 1;
+      unsigned h248MessagePresent : 1;
+   } m;
+   H225NonStandardParameter nonStandard;
+   ASN1DynOctStr h248Message;
+} H225StimulusControl;
+
+EXTERN int asn1PE_H225StimulusControl (OOCTXT* pctxt, H225StimulusControl* pvalue);
+
+EXTERN int asn1PD_H225StimulusControl (OOCTXT* pctxt, H225StimulusControl* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323_UU_PDU {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned h4501SupplementaryServicePresent : 1;
+      unsigned h245TunnelingPresent : 1;
+      unsigned h245ControlPresent : 1;
+      unsigned nonStandardControlPresent : 1;
+      unsigned callLinkagePresent : 1;
+      unsigned tunnelledSignallingMessagePresent : 1;
+      unsigned provisionalRespToH245TunnelingPresent : 1;
+      unsigned stimulusControlPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225H323_UU_PDU_h323_message_body h323_message_body;
+   H225NonStandardParameter nonStandardData;
+   H225H323_UU_PDU_h4501SupplementaryService h4501SupplementaryService;
+   ASN1BOOL h245Tunneling;
+   H225H323_UU_PDU_h245Control h245Control;
+   H225_SeqOfH225NonStandardParameter nonStandardControl;
+   H225CallLinkage callLinkage;
+   H225H323_UU_PDU_tunnelledSignallingMessage tunnelledSignallingMessage;
+   H225StimulusControl stimulusControl;
+   H225_SeqOfH225GenericData genericData;
+} H225H323_UU_PDU;
+
+EXTERN int asn1PE_H225H323_UU_PDU (OOCTXT* pctxt, H225H323_UU_PDU* pvalue);
+
+EXTERN int asn1PD_H225H323_UU_PDU (OOCTXT* pctxt, H225H323_UU_PDU* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation_user_data                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323_UserInformation_user_data {
+   ASN1UINT8 protocol_discriminator;
+   H225H323_UserInformation_user_data_user_information user_information;
+} H225H323_UserInformation_user_data;
+
+EXTERN int asn1PE_H225H323_UserInformation_user_data (OOCTXT* pctxt, H225H323_UserInformation_user_data* pvalue);
+
+EXTERN int asn1PD_H225H323_UserInformation_user_data (OOCTXT* pctxt, H225H323_UserInformation_user_data* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225H323_UserInformation {
+   struct {
+      unsigned user_dataPresent : 1;
+   } m;
+   H225H323_UU_PDU h323_uu_pdu;
+   H225H323_UserInformation_user_data user_data;
+} H225H323_UserInformation;
+
+EXTERN int asn1PE_H225H323_UserInformation (OOCTXT* pctxt, H225H323_UserInformation* pvalue);
+
+EXTERN int asn1PD_H225H323_UserInformation (OOCTXT* pctxt, H225H323_UserInformation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AddressPattern_range                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225AddressPattern_range {
+   H225PartyNumber startOfRange;
+   H225PartyNumber endOfRange;
+} H225AddressPattern_range;
+
+EXTERN int asn1PE_H225AddressPattern_range (OOCTXT* pctxt, H225AddressPattern_range* pvalue);
+
+EXTERN int asn1PD_H225AddressPattern_range (OOCTXT* pctxt, H225AddressPattern_range* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AddressPattern                                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225AddressPattern_wildcard   1
+#define T_H225AddressPattern_range      2
+#define T_H225AddressPattern_extElem1   3
+
+typedef struct EXTERN H225AddressPattern {
+   int t;
+   union {
+      /* t = 1 */
+      H225AliasAddress *wildcard;
+      /* t = 2 */
+      H225AddressPattern_range *range;
+      /* t = 3 */
+   } u;
+} H225AddressPattern;
+
+EXTERN int asn1PE_H225AddressPattern (OOCTXT* pctxt, H225AddressPattern* pvalue);
+
+EXTERN int asn1PD_H225AddressPattern (OOCTXT* pctxt, H225AddressPattern* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportAddress                                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225TransportAddress */
+typedef DList H225_SeqOfH225TransportAddress;
+
+EXTERN int asn1PE_H225_SeqOfH225TransportAddress (OOCTXT* pctxt, H225_SeqOfH225TransportAddress* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225TransportAddress (OOCTXT* pctxt, H225_SeqOfH225TransportAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AlternateTransportAddresses                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225AlternateTransportAddresses {
+   struct {
+      unsigned annexEPresent : 1;
+      unsigned sctpPresent : 1;
+   } m;
+   H225_SeqOfH225TransportAddress annexE;
+   H225_SeqOfH225TransportAddress sctp;
+} H225AlternateTransportAddresses;
+
+EXTERN int asn1PE_H225AlternateTransportAddresses (OOCTXT* pctxt, H225AlternateTransportAddresses* pvalue);
+
+EXTERN int asn1PD_H225AlternateTransportAddresses (OOCTXT* pctxt, H225AlternateTransportAddresses* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Endpoint                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225Endpoint {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned aliasAddressPresent : 1;
+      unsigned callSignalAddressPresent : 1;
+      unsigned rasAddressPresent : 1;
+      unsigned endpointTypePresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned priorityPresent : 1;
+      unsigned remoteExtensionAddressPresent : 1;
+      unsigned destExtraCallInfoPresent : 1;
+      unsigned alternateTransportAddressesPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned featureSetPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225AliasAddress aliasAddress;
+   H225_SeqOfH225TransportAddress callSignalAddress;
+   H225_SeqOfH225TransportAddress rasAddress;
+   H225EndpointType endpointType;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   ASN1UINT8 priority;
+   H225_SeqOfH225AliasAddress remoteExtensionAddress;
+   H225_SeqOfH225AliasAddress destExtraCallInfo;
+   H225AlternateTransportAddresses alternateTransportAddresses;
+   H225CircuitInfo circuitInfo;
+   H225FeatureSet featureSet;
+} H225Endpoint;
+
+EXTERN int asn1PE_H225Endpoint (OOCTXT* pctxt, H225Endpoint* pvalue);
+
+EXTERN int asn1PD_H225Endpoint (OOCTXT* pctxt, H225Endpoint* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UseSpecifiedTransport                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225UseSpecifiedTransport_tcp 1
+#define T_H225UseSpecifiedTransport_annexE 2
+#define T_H225UseSpecifiedTransport_sctp 3
+#define T_H225UseSpecifiedTransport_extElem1 4
+
+typedef struct EXTERN H225UseSpecifiedTransport {
+   int t;
+} H225UseSpecifiedTransport;
+
+EXTERN int asn1PE_H225UseSpecifiedTransport (OOCTXT* pctxt, H225UseSpecifiedTransport* pvalue);
+
+EXTERN int asn1PD_H225UseSpecifiedTransport (OOCTXT* pctxt, H225UseSpecifiedTransport* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AlternateGK                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225AlternateGK {
+   struct {
+      unsigned gatekeeperIdentifierPresent : 1;
+   } m;
+   H225TransportAddress rasAddress;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   ASN1BOOL needToRegister;
+   ASN1UINT8 priority;
+} H225AlternateGK;
+
+EXTERN int asn1PE_H225AlternateGK (OOCTXT* pctxt, H225AlternateGK* pvalue);
+
+EXTERN int asn1PD_H225AlternateGK (OOCTXT* pctxt, H225AlternateGK* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AlternateGK                                     */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225AlternateGK */
+typedef DList H225_SeqOfH225AlternateGK;
+
+EXTERN int asn1PE_H225_SeqOfH225AlternateGK (OOCTXT* pctxt, H225_SeqOfH225AlternateGK* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225AlternateGK (OOCTXT* pctxt, H225_SeqOfH225AlternateGK* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AltGKInfo                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225AltGKInfo {
+   H225_SeqOfH225AlternateGK alternateGatekeeper;
+   ASN1BOOL altGKisPermanent;
+} H225AltGKInfo;
+
+EXTERN int asn1PE_H225AltGKInfo (OOCTXT* pctxt, H225AltGKInfo* pvalue);
+
+EXTERN int asn1PD_H225AltGKInfo (OOCTXT* pctxt, H225AltGKInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityErrors2                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225SecurityErrors2_securityWrongSyncTime 1
+#define T_H225SecurityErrors2_securityReplay 2
+#define T_H225SecurityErrors2_securityWrongGeneralID 3
+#define T_H225SecurityErrors2_securityWrongSendersID 4
+#define T_H225SecurityErrors2_securityIntegrityFailed 5
+#define T_H225SecurityErrors2_securityWrongOID 6
+#define T_H225SecurityErrors2_extElem1  7
+
+typedef struct EXTERN H225SecurityErrors2 {
+   int t;
+} H225SecurityErrors2;
+
+EXTERN int asn1PE_H225SecurityErrors2 (OOCTXT* pctxt, H225SecurityErrors2* pvalue);
+
+EXTERN int asn1PD_H225SecurityErrors2 (OOCTXT* pctxt, H225SecurityErrors2* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptIntAlg                                             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225EncryptIntAlg_nonStandard 1
+#define T_H225EncryptIntAlg_isoAlgorithm 2
+#define T_H225EncryptIntAlg_extElem1    3
+
+typedef struct EXTERN H225EncryptIntAlg {
+   int t;
+   union {
+      /* t = 1 */
+      H225NonStandardParameter *nonStandard;
+      /* t = 2 */
+      ASN1OBJID *isoAlgorithm;
+      /* t = 3 */
+   } u;
+} H225EncryptIntAlg;
+
+EXTERN int asn1PE_H225EncryptIntAlg (OOCTXT* pctxt, H225EncryptIntAlg* pvalue);
+
+EXTERN int asn1PD_H225EncryptIntAlg (OOCTXT* pctxt, H225EncryptIntAlg* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonIsoIntegrityMechanism                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225NonIsoIntegrityMechanism_hMAC_MD5 1
+#define T_H225NonIsoIntegrityMechanism_hMAC_iso10118_2_s 2
+#define T_H225NonIsoIntegrityMechanism_hMAC_iso10118_2_l 3
+#define T_H225NonIsoIntegrityMechanism_hMAC_iso10118_3 4
+#define T_H225NonIsoIntegrityMechanism_extElem1 5
+
+typedef struct EXTERN H225NonIsoIntegrityMechanism {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H225EncryptIntAlg *hMAC_iso10118_2_s;
+      /* t = 3 */
+      H225EncryptIntAlg *hMAC_iso10118_2_l;
+      /* t = 4 */
+      ASN1OBJID *hMAC_iso10118_3;
+      /* t = 5 */
+   } u;
+} H225NonIsoIntegrityMechanism;
+
+EXTERN int asn1PE_H225NonIsoIntegrityMechanism (OOCTXT* pctxt, H225NonIsoIntegrityMechanism* pvalue);
+
+EXTERN int asn1PD_H225NonIsoIntegrityMechanism (OOCTXT* pctxt, H225NonIsoIntegrityMechanism* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IntegrityMechanism                                        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225IntegrityMechanism_nonStandard 1
+#define T_H225IntegrityMechanism_digSig 2
+#define T_H225IntegrityMechanism_iso9797 3
+#define T_H225IntegrityMechanism_nonIsoIM 4
+#define T_H225IntegrityMechanism_extElem1 5
+
+typedef struct EXTERN H225IntegrityMechanism {
+   int t;
+   union {
+      /* t = 1 */
+      H225NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      ASN1OBJID *iso9797;
+      /* t = 4 */
+      H225NonIsoIntegrityMechanism *nonIsoIM;
+      /* t = 5 */
+   } u;
+} H225IntegrityMechanism;
+
+EXTERN int asn1PE_H225IntegrityMechanism (OOCTXT* pctxt, H225IntegrityMechanism* pvalue);
+
+EXTERN int asn1PD_H225IntegrityMechanism (OOCTXT* pctxt, H225IntegrityMechanism* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ICV                                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ICV {
+   ASN1OBJID algorithmOID;
+   ASN1DynBitStr icv;
+} H225ICV;
+
+EXTERN int asn1PE_H225ICV (OOCTXT* pctxt, H225ICV* pvalue);
+
+EXTERN int asn1PD_H225ICV (OOCTXT* pctxt, H225ICV* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingCapability                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CapacityReportingCapability {
+   ASN1BOOL canReportCallCapacity;
+} H225CapacityReportingCapability;
+
+EXTERN int asn1PE_H225CapacityReportingCapability (OOCTXT* pctxt, H225CapacityReportingCapability* pvalue);
+
+EXTERN int asn1PD_H225CapacityReportingCapability (OOCTXT* pctxt, H225CapacityReportingCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingSpecification_when                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CapacityReportingSpecification_when {
+   struct {
+      unsigned callStartPresent : 1;
+      unsigned callEndPresent : 1;
+   } m;
+   ASN1OCTET __dummy__;
+} H225CapacityReportingSpecification_when;
+
+EXTERN int asn1PE_H225CapacityReportingSpecification_when (OOCTXT* pctxt, H225CapacityReportingSpecification_when* pvalue);
+
+EXTERN int asn1PD_H225CapacityReportingSpecification_when (OOCTXT* pctxt, H225CapacityReportingSpecification_when* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingSpecification                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CapacityReportingSpecification {
+   H225CapacityReportingSpecification_when when;
+} H225CapacityReportingSpecification;
+
+EXTERN int asn1PE_H225CapacityReportingSpecification (OOCTXT* pctxt, H225CapacityReportingSpecification* pvalue);
+
+EXTERN int asn1PD_H225CapacityReportingSpecification (OOCTXT* pctxt, H225CapacityReportingSpecification* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageInfoTypes                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RasUsageInfoTypes {
+   struct {
+      unsigned startTimePresent : 1;
+      unsigned endTimePresent : 1;
+      unsigned terminationCausePresent : 1;
+   } m;
+   H225_SeqOfH225NonStandardParameter nonStandardUsageTypes;
+} H225RasUsageInfoTypes;
+
+EXTERN int asn1PE_H225RasUsageInfoTypes (OOCTXT* pctxt, H225RasUsageInfoTypes* pvalue);
+
+EXTERN int asn1PD_H225RasUsageInfoTypes (OOCTXT* pctxt, H225RasUsageInfoTypes* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification_when                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RasUsageSpecification_when {
+   struct {
+      unsigned startPresent : 1;
+      unsigned endPresent : 1;
+      unsigned inIrrPresent : 1;
+   } m;
+   ASN1OCTET __dummy__;
+} H225RasUsageSpecification_when;
+
+EXTERN int asn1PE_H225RasUsageSpecification_when (OOCTXT* pctxt, H225RasUsageSpecification_when* pvalue);
+
+EXTERN int asn1PD_H225RasUsageSpecification_when (OOCTXT* pctxt, H225RasUsageSpecification_when* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification_callStartingPoint                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RasUsageSpecification_callStartingPoint {
+   struct {
+      unsigned alertingPresent : 1;
+      unsigned connectPresent : 1;
+   } m;
+   ASN1OCTET __dummy__;
+} H225RasUsageSpecification_callStartingPoint;
+
+EXTERN int asn1PE_H225RasUsageSpecification_callStartingPoint (OOCTXT* pctxt, H225RasUsageSpecification_callStartingPoint* pvalue);
+
+EXTERN int asn1PD_H225RasUsageSpecification_callStartingPoint (OOCTXT* pctxt, H225RasUsageSpecification_callStartingPoint* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RasUsageSpecification {
+   struct {
+      unsigned callStartingPointPresent : 1;
+   } m;
+   H225RasUsageSpecification_when when;
+   H225RasUsageSpecification_callStartingPoint callStartingPoint;
+   H225RasUsageInfoTypes required;
+} H225RasUsageSpecification;
+
+EXTERN int asn1PE_H225RasUsageSpecification (OOCTXT* pctxt, H225RasUsageSpecification* pvalue);
+
+EXTERN int asn1PD_H225RasUsageSpecification (OOCTXT* pctxt, H225RasUsageSpecification* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageInformation                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RasUsageInformation {
+   struct {
+      unsigned alertingTimePresent : 1;
+      unsigned connectTimePresent : 1;
+      unsigned endTimePresent : 1;
+   } m;
+   H225_SeqOfH225NonStandardParameter nonStandardUsageFields;
+   H235TimeStamp alertingTime;
+   H235TimeStamp connectTime;
+   H235TimeStamp endTime;
+} H225RasUsageInformation;
+
+EXTERN int asn1PE_H225RasUsageInformation (OOCTXT* pctxt, H225RasUsageInformation* pvalue);
+
+EXTERN int asn1PD_H225RasUsageInformation (OOCTXT* pctxt, H225RasUsageInformation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallTerminationCause                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225CallTerminationCause_releaseCompleteReason 1
+#define T_H225CallTerminationCause_releaseCompleteCauseIE 2
+#define T_H225CallTerminationCause_extElem1 3
+
+typedef struct EXTERN H225CallTerminationCause {
+   int t;
+   union {
+      /* t = 1 */
+      H225ReleaseCompleteReason *releaseCompleteReason;
+      /* t = 2 */
+      H225CallTerminationCause_releaseCompleteCauseIE *releaseCompleteCauseIE;
+      /* t = 3 */
+   } u;
+} H225CallTerminationCause;
+
+EXTERN int asn1PE_H225CallTerminationCause (OOCTXT* pctxt, H225CallTerminationCause* pvalue);
+
+EXTERN int asn1PD_H225CallTerminationCause (OOCTXT* pctxt, H225CallTerminationCause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportChannelInfo                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225TransportChannelInfo {
+   struct {
+      unsigned sendAddressPresent : 1;
+      unsigned recvAddressPresent : 1;
+   } m;
+   H225TransportAddress sendAddress;
+   H225TransportAddress recvAddress;
+} H225TransportChannelInfo;
+
+EXTERN int asn1PE_H225TransportChannelInfo (OOCTXT* pctxt, H225TransportChannelInfo* pvalue);
+
+EXTERN int asn1PD_H225TransportChannelInfo (OOCTXT* pctxt, H225TransportChannelInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthDetails                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225BandwidthDetails {
+   ASN1BOOL sender;
+   ASN1BOOL multicast;
+   H225BandWidth bandwidth;
+   H225TransportChannelInfo rtcpAddresses;
+} H225BandwidthDetails;
+
+EXTERN int asn1PE_H225BandwidthDetails (OOCTXT* pctxt, H225BandwidthDetails* pvalue);
+
+EXTERN int asn1PD_H225BandwidthDetails (OOCTXT* pctxt, H225BandwidthDetails* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225CallCreditCapability {
+   struct {
+      unsigned canDisplayAmountStringPresent : 1;
+      unsigned canEnforceDurationLimitPresent : 1;
+   } m;
+   ASN1BOOL canDisplayAmountString;
+   ASN1BOOL canEnforceDurationLimit;
+} H225CallCreditCapability;
+
+EXTERN int asn1PE_H225CallCreditCapability (OOCTXT* pctxt, H225CallCreditCapability* pvalue);
+
+EXTERN int asn1PD_H225CallCreditCapability (OOCTXT* pctxt, H225CallCreditCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPSession_associatedSessionIds                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RTPSession_associatedSessionIds {
+   ASN1UINT n;
+   ASN1UINT8 *elem;
+} H225RTPSession_associatedSessionIds;
+
+EXTERN int asn1PE_H225RTPSession_associatedSessionIds (OOCTXT* pctxt, H225RTPSession_associatedSessionIds* pvalue);
+
+EXTERN int asn1PD_H225RTPSession_associatedSessionIds (OOCTXT* pctxt, H225RTPSession_associatedSessionIds* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPSession                                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RTPSession {
+   struct {
+      unsigned multicastPresent : 1;
+      unsigned bandwidthPresent : 1;
+   } m;
+   H225TransportChannelInfo rtpAddress;
+   H225TransportChannelInfo rtcpAddress;
+   ASN1PrintableString cname;
+   ASN1UINT ssrc;
+   ASN1UINT8 sessionId;
+   H225RTPSession_associatedSessionIds associatedSessionIds;
+   H225BandWidth bandwidth;
+} H225RTPSession;
+
+EXTERN int asn1PE_H225RTPSession (OOCTXT* pctxt, H225RTPSession* pvalue);
+
+EXTERN int asn1PD_H225RTPSession (OOCTXT* pctxt, H225RTPSession* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225Endpoint                                        */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225Endpoint */
+typedef DList H225_SeqOfH225Endpoint;
+
+EXTERN int asn1PE_H225_SeqOfH225Endpoint (OOCTXT* pctxt, H225_SeqOfH225Endpoint* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225Endpoint (OOCTXT* pctxt, H225_SeqOfH225Endpoint* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AuthenticationMechanism                         */
+/*                                                            */
+/**************************************************************/
+
+/* List of H235AuthenticationMechanism */
+typedef DList H225_SeqOfH225AuthenticationMechanism;
+
+EXTERN int asn1PE_H225_SeqOfH225AuthenticationMechanism (OOCTXT* pctxt, H225_SeqOfH225AuthenticationMechanism* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225AuthenticationMechanism (OOCTXT* pctxt, H225_SeqOfH225AuthenticationMechanism* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRequest_algorithmOIDs                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GatekeeperRequest_algorithmOIDs {
+   ASN1UINT n;
+   ASN1OBJID *elem;
+} H225GatekeeperRequest_algorithmOIDs;
+
+EXTERN int asn1PE_H225GatekeeperRequest_algorithmOIDs (OOCTXT* pctxt, H225GatekeeperRequest_algorithmOIDs* pvalue);
+
+EXTERN int asn1PD_H225GatekeeperRequest_algorithmOIDs (OOCTXT* pctxt, H225GatekeeperRequest_algorithmOIDs* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225IntegrityMechanism                              */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225IntegrityMechanism */
+typedef DList H225_SeqOfH225IntegrityMechanism;
+
+EXTERN int asn1PE_H225_SeqOfH225IntegrityMechanism (OOCTXT* pctxt, H225_SeqOfH225IntegrityMechanism* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225IntegrityMechanism (OOCTXT* pctxt, H225_SeqOfH225IntegrityMechanism* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRequest                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GatekeeperRequest {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned callServicesPresent : 1;
+      unsigned endpointAliasPresent : 1;
+      unsigned alternateEndpointsPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned authenticationCapabilityPresent : 1;
+      unsigned algorithmOIDsPresent : 1;
+      unsigned integrityPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned supportsAltGKPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225NonStandardParameter nonStandardData;
+   H225TransportAddress rasAddress;
+   H225EndpointType endpointType;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225QseriesOptions callServices;
+   H225_SeqOfH225AliasAddress endpointAlias;
+   H225_SeqOfH225Endpoint alternateEndpoints;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225_SeqOfH225AuthenticationMechanism authenticationCapability;
+   H225GatekeeperRequest_algorithmOIDs algorithmOIDs;
+   H225_SeqOfH225IntegrityMechanism integrity;
+   H225ICV integrityCheckValue;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225GatekeeperRequest;
+
+EXTERN int asn1PE_H225GatekeeperRequest (OOCTXT* pctxt, H225GatekeeperRequest* pvalue);
+
+EXTERN int asn1PD_H225GatekeeperRequest (OOCTXT* pctxt, H225GatekeeperRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperConfirm                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GatekeeperConfirm {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned alternateGatekeeperPresent : 1;
+      unsigned authenticationModePresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned algorithmOIDPresent : 1;
+      unsigned integrityPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225NonStandardParameter nonStandardData;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225TransportAddress rasAddress;
+   H225_SeqOfH225AlternateGK alternateGatekeeper;
+   H235AuthenticationMechanism authenticationMode;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   ASN1OBJID algorithmOID;
+   H225_SeqOfH225IntegrityMechanism integrity;
+   H225ICV integrityCheckValue;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225GatekeeperConfirm;
+
+EXTERN int asn1PE_H225GatekeeperConfirm (OOCTXT* pctxt, H225GatekeeperConfirm* pvalue);
+
+EXTERN int asn1PD_H225GatekeeperConfirm (OOCTXT* pctxt, H225GatekeeperConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRejectReason                                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225GatekeeperRejectReason_resourceUnavailable 1
+#define T_H225GatekeeperRejectReason_terminalExcluded 2
+#define T_H225GatekeeperRejectReason_invalidRevision 3
+#define T_H225GatekeeperRejectReason_undefinedReason 4
+#define T_H225GatekeeperRejectReason_securityDenial 5
+#define T_H225GatekeeperRejectReason_genericDataReason 6
+#define T_H225GatekeeperRejectReason_neededFeatureNotSupported 7
+#define T_H225GatekeeperRejectReason_securityError 8
+#define T_H225GatekeeperRejectReason_extElem1 9
+
+typedef struct EXTERN H225GatekeeperRejectReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      H225SecurityErrors *securityError;
+      /* t = 9 */
+   } u;
+} H225GatekeeperRejectReason;
+
+EXTERN int asn1PE_H225GatekeeperRejectReason (OOCTXT* pctxt, H225GatekeeperRejectReason* pvalue);
+
+EXTERN int asn1PD_H225GatekeeperRejectReason (OOCTXT* pctxt, H225GatekeeperRejectReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperReject                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225GatekeeperReject {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned altGKInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225NonStandardParameter nonStandardData;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225GatekeeperRejectReason rejectReason;
+   H225AltGKInfo altGKInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225GatekeeperReject;
+
+EXTERN int asn1PE_H225GatekeeperReject (OOCTXT* pctxt, H225GatekeeperReject* pvalue);
+
+EXTERN int asn1PD_H225GatekeeperReject (OOCTXT* pctxt, H225GatekeeperReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AddressPattern                                  */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225AddressPattern */
+typedef DList H225_SeqOfH225AddressPattern;
+
+EXTERN int asn1PE_H225_SeqOfH225AddressPattern (OOCTXT* pctxt, H225_SeqOfH225AddressPattern* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225AddressPattern (OOCTXT* pctxt, H225_SeqOfH225AddressPattern* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225H248PackagesDescriptor                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225_SeqOfH225H248PackagesDescriptor {
+   ASN1UINT n;
+   H225H248PackagesDescriptor *elem;
+} H225_SeqOfH225H248PackagesDescriptor;
+
+EXTERN int asn1PE_H225_SeqOfH225H248PackagesDescriptor (OOCTXT* pctxt, H225_SeqOfH225H248PackagesDescriptor* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225H248PackagesDescriptor (OOCTXT* pctxt, H225_SeqOfH225H248PackagesDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRequest                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RegistrationRequest {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned terminalAliasPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned alternateEndpointsPresent : 1;
+      unsigned timeToLivePresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned keepAlivePresent : 1;
+      unsigned endpointIdentifierPresent : 1;
+      unsigned willSupplyUUIEsPresent : 1;
+      unsigned maintainConnectionPresent : 1;
+      unsigned alternateTransportAddressesPresent : 1;
+      unsigned additiveRegistrationPresent : 1;
+      unsigned terminalAliasPatternPresent : 1;
+      unsigned supportsAltGKPresent : 1;
+      unsigned usageReportingCapabilityPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned supportedH248PackagesPresent : 1;
+      unsigned callCreditCapabilityPresent : 1;
+      unsigned capacityReportingCapabilityPresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+      unsigned restartPresent : 1;
+      unsigned supportsACFSequencesPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225NonStandardParameter nonStandardData;
+   ASN1BOOL discoveryComplete;
+   H225_SeqOfH225TransportAddress callSignalAddress;
+   H225_SeqOfH225TransportAddress rasAddress;
+   H225EndpointType terminalType;
+   H225_SeqOfH225AliasAddress terminalAlias;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225VendorIdentifier endpointVendor;
+   H225_SeqOfH225Endpoint alternateEndpoints;
+   H225TimeToLive timeToLive;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   ASN1BOOL keepAlive;
+   H225EndpointIdentifier endpointIdentifier;
+   ASN1BOOL willSupplyUUIEs;
+   ASN1BOOL maintainConnection;
+   H225AlternateTransportAddresses alternateTransportAddresses;
+   H225_SeqOfH225AddressPattern terminalAliasPattern;
+   H225RasUsageInfoTypes usageReportingCapability;
+   ASN1BOOL multipleCalls;
+   H225_SeqOfH225H248PackagesDescriptor supportedH248Packages;
+   H225CallCreditCapability callCreditCapability;
+   H225CapacityReportingCapability capacityReportingCapability;
+   H225CallCapacity capacity;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225RegistrationRequest;
+
+EXTERN int asn1PE_H225RegistrationRequest (OOCTXT* pctxt, H225RegistrationRequest* pvalue);
+
+EXTERN int asn1PD_H225RegistrationRequest (OOCTXT* pctxt, H225RegistrationRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationConfirm_preGrantedARQ                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RegistrationConfirm_preGrantedARQ {
+   struct {
+      unsigned irrFrequencyInCallPresent : 1;
+      unsigned totalBandwidthRestrictionPresent : 1;
+      unsigned alternateTransportAddressesPresent : 1;
+      unsigned useSpecifiedTransportPresent : 1;
+   } m;
+   ASN1BOOL makeCall;
+   ASN1BOOL useGKCallSignalAddressToMakeCall;
+   ASN1BOOL answerCall;
+   ASN1BOOL useGKCallSignalAddressToAnswer;
+   ASN1USINT irrFrequencyInCall;
+   H225BandWidth totalBandwidthRestriction;
+   H225AlternateTransportAddresses alternateTransportAddresses;
+   H225UseSpecifiedTransport useSpecifiedTransport;
+} H225RegistrationConfirm_preGrantedARQ;
+
+EXTERN int asn1PE_H225RegistrationConfirm_preGrantedARQ (OOCTXT* pctxt, H225RegistrationConfirm_preGrantedARQ* pvalue);
+
+EXTERN int asn1PD_H225RegistrationConfirm_preGrantedARQ (OOCTXT* pctxt, H225RegistrationConfirm_preGrantedARQ* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225RasUsageSpecification                           */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225RasUsageSpecification */
+typedef DList H225_SeqOfH225RasUsageSpecification;
+
+EXTERN int asn1PE_H225_SeqOfH225RasUsageSpecification (OOCTXT* pctxt, H225_SeqOfH225RasUsageSpecification* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225RasUsageSpecification (OOCTXT* pctxt, H225_SeqOfH225RasUsageSpecification* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationConfirm                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RegistrationConfirm {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned terminalAliasPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned alternateGatekeeperPresent : 1;
+      unsigned timeToLivePresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned willRespondToIRRPresent : 1;
+      unsigned preGrantedARQPresent : 1;
+      unsigned maintainConnectionPresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned supportsAdditiveRegistrationPresent : 1;
+      unsigned terminalAliasPatternPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+      unsigned usageSpecPresent : 1;
+      unsigned featureServerAliasPresent : 1;
+      unsigned capacityReportingSpecPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225TransportAddress callSignalAddress;
+   H225_SeqOfH225AliasAddress terminalAlias;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225EndpointIdentifier endpointIdentifier;
+   H225_SeqOfH225AlternateGK alternateGatekeeper;
+   H225TimeToLive timeToLive;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   ASN1BOOL willRespondToIRR;
+   H225RegistrationConfirm_preGrantedARQ preGrantedARQ;
+   ASN1BOOL maintainConnection;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225_SeqOfH225AddressPattern terminalAliasPattern;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+   H225_SeqOfH225RasUsageSpecification usageSpec;
+   H225AliasAddress featureServerAlias;
+   H225CapacityReportingSpecification capacityReportingSpec;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225RegistrationConfirm;
+
+EXTERN int asn1PE_H225RegistrationConfirm (OOCTXT* pctxt, H225RegistrationConfirm* pvalue);
+
+EXTERN int asn1PD_H225RegistrationConfirm (OOCTXT* pctxt, H225RegistrationConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRejectReason_invalidTerminalAliases           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RegistrationRejectReason_invalidTerminalAliases {
+   struct {
+      unsigned terminalAliasPresent : 1;
+      unsigned terminalAliasPatternPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+   } m;
+   H225_SeqOfH225AliasAddress terminalAlias;
+   H225_SeqOfH225AddressPattern terminalAliasPattern;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+} H225RegistrationRejectReason_invalidTerminalAliases;
+
+EXTERN int asn1PE_H225RegistrationRejectReason_invalidTerminalAliases (OOCTXT* pctxt, H225RegistrationRejectReason_invalidTerminalAliases* pvalue);
+
+EXTERN int asn1PD_H225RegistrationRejectReason_invalidTerminalAliases (OOCTXT* pctxt, H225RegistrationRejectReason_invalidTerminalAliases* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRejectReason                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225RegistrationRejectReason_discoveryRequired 1
+#define T_H225RegistrationRejectReason_invalidRevision 2
+#define T_H225RegistrationRejectReason_invalidCallSignalAddress 3
+#define T_H225RegistrationRejectReason_invalidRASAddress 4
+#define T_H225RegistrationRejectReason_duplicateAlias 5
+#define T_H225RegistrationRejectReason_invalidTerminalType 6
+#define T_H225RegistrationRejectReason_undefinedReason 7
+#define T_H225RegistrationRejectReason_transportNotSupported 8
+#define T_H225RegistrationRejectReason_transportQOSNotSupported 9
+#define T_H225RegistrationRejectReason_resourceUnavailable 10
+#define T_H225RegistrationRejectReason_invalidAlias 11
+#define T_H225RegistrationRejectReason_securityDenial 12
+#define T_H225RegistrationRejectReason_fullRegistrationRequired 13
+#define T_H225RegistrationRejectReason_additiveRegistrationNotSupported 14
+#define T_H225RegistrationRejectReason_invalidTerminalAliases 15
+#define T_H225RegistrationRejectReason_genericDataReason 16
+#define T_H225RegistrationRejectReason_neededFeatureNotSupported 17
+#define T_H225RegistrationRejectReason_securityError 18
+#define T_H225RegistrationRejectReason_extElem1 19
+
+typedef struct EXTERN H225RegistrationRejectReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      H225_SeqOfH225AliasAddress *duplicateAlias;
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      /* t = 9 */
+      /* t = 10 */
+      /* t = 11 */
+      /* t = 12 */
+      /* t = 13 */
+      /* t = 14 */
+      /* t = 15 */
+      H225RegistrationRejectReason_invalidTerminalAliases *invalidTerminalAliases;
+      /* t = 16 */
+      /* t = 17 */
+      /* t = 18 */
+      H225SecurityErrors *securityError;
+      /* t = 19 */
+   } u;
+} H225RegistrationRejectReason;
+
+EXTERN int asn1PE_H225RegistrationRejectReason (OOCTXT* pctxt, H225RegistrationRejectReason* pvalue);
+
+EXTERN int asn1PD_H225RegistrationRejectReason (OOCTXT* pctxt, H225RegistrationRejectReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationReject                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RegistrationReject {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned altGKInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225NonStandardParameter nonStandardData;
+   H225RegistrationRejectReason rejectReason;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225AltGKInfo altGKInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225RegistrationReject;
+
+EXTERN int asn1PE_H225RegistrationReject (OOCTXT* pctxt, H225RegistrationReject* pvalue);
+
+EXTERN int asn1PD_H225RegistrationReject (OOCTXT* pctxt, H225RegistrationReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnregRequestReason                                        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225UnregRequestReason_reregistrationRequired 1
+#define T_H225UnregRequestReason_ttlExpired 2
+#define T_H225UnregRequestReason_securityDenial 3
+#define T_H225UnregRequestReason_undefinedReason 4
+#define T_H225UnregRequestReason_maintenance 5
+#define T_H225UnregRequestReason_securityError 6
+#define T_H225UnregRequestReason_extElem1 7
+
+typedef struct EXTERN H225UnregRequestReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      H225SecurityErrors2 *securityError;
+      /* t = 7 */
+   } u;
+} H225UnregRequestReason;
+
+EXTERN int asn1PE_H225UnregRequestReason (OOCTXT* pctxt, H225UnregRequestReason* pvalue);
+
+EXTERN int asn1PD_H225UnregRequestReason (OOCTXT* pctxt, H225UnregRequestReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationRequest                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225UnregistrationRequest {
+   struct {
+      unsigned endpointAliasPresent : 1;
+      unsigned nonStandardDataPresent : 1;
+      unsigned endpointIdentifierPresent : 1;
+      unsigned alternateEndpointsPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned reasonPresent : 1;
+      unsigned endpointAliasPatternPresent : 1;
+      unsigned supportedPrefixesPresent : 1;
+      unsigned alternateGatekeeperPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225_SeqOfH225TransportAddress callSignalAddress;
+   H225_SeqOfH225AliasAddress endpointAlias;
+   H225NonStandardParameter nonStandardData;
+   H225EndpointIdentifier endpointIdentifier;
+   H225_SeqOfH225Endpoint alternateEndpoints;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225UnregRequestReason reason;
+   H225_SeqOfH225AddressPattern endpointAliasPattern;
+   H225_SeqOfH225SupportedPrefix supportedPrefixes;
+   H225_SeqOfH225AlternateGK alternateGatekeeper;
+   H225_SeqOfH225GenericData genericData;
+} H225UnregistrationRequest;
+
+EXTERN int asn1PE_H225UnregistrationRequest (OOCTXT* pctxt, H225UnregistrationRequest* pvalue);
+
+EXTERN int asn1PD_H225UnregistrationRequest (OOCTXT* pctxt, H225UnregistrationRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationConfirm                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225UnregistrationConfirm {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225_SeqOfH225GenericData genericData;
+} H225UnregistrationConfirm;
+
+EXTERN int asn1PE_H225UnregistrationConfirm (OOCTXT* pctxt, H225UnregistrationConfirm* pvalue);
+
+EXTERN int asn1PD_H225UnregistrationConfirm (OOCTXT* pctxt, H225UnregistrationConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnregRejectReason                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225UnregRejectReason_notCurrentlyRegistered 1
+#define T_H225UnregRejectReason_callInProgress 2
+#define T_H225UnregRejectReason_undefinedReason 3
+#define T_H225UnregRejectReason_permissionDenied 4
+#define T_H225UnregRejectReason_securityDenial 5
+#define T_H225UnregRejectReason_securityError 6
+#define T_H225UnregRejectReason_extElem1 7
+
+typedef struct EXTERN H225UnregRejectReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      H225SecurityErrors2 *securityError;
+      /* t = 7 */
+   } u;
+} H225UnregRejectReason;
+
+EXTERN int asn1PE_H225UnregRejectReason (OOCTXT* pctxt, H225UnregRejectReason* pvalue);
+
+EXTERN int asn1PD_H225UnregRejectReason (OOCTXT* pctxt, H225UnregRejectReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationReject                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225UnregistrationReject {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned altGKInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225UnregRejectReason rejectReason;
+   H225NonStandardParameter nonStandardData;
+   H225AltGKInfo altGKInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225_SeqOfH225GenericData genericData;
+} H225UnregistrationReject;
+
+EXTERN int asn1PE_H225UnregistrationReject (OOCTXT* pctxt, H225UnregistrationReject* pvalue);
+
+EXTERN int asn1PD_H225UnregistrationReject (OOCTXT* pctxt, H225UnregistrationReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CallModel                                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225CallModel_direct          1
+#define T_H225CallModel_gatekeeperRouted 2
+#define T_H225CallModel_extElem1        3
+
+typedef struct EXTERN H225CallModel {
+   int t;
+} H225CallModel;
+
+EXTERN int asn1PE_H225CallModel (OOCTXT* pctxt, H225CallModel* pvalue);
+
+EXTERN int asn1PD_H225CallModel (OOCTXT* pctxt, H225CallModel* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportQOS                                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225TransportQOS_endpointControlled 1
+#define T_H225TransportQOS_gatekeeperControlled 2
+#define T_H225TransportQOS_noControl    3
+#define T_H225TransportQOS_extElem1     4
+
+typedef struct EXTERN H225TransportQOS {
+   int t;
+} H225TransportQOS;
+
+EXTERN int asn1PE_H225TransportQOS (OOCTXT* pctxt, H225TransportQOS* pvalue);
+
+EXTERN int asn1PD_H225TransportQOS (OOCTXT* pctxt, H225TransportQOS* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225AdmissionRequest {
+   struct {
+      unsigned callModelPresent : 1;
+      unsigned destinationInfoPresent : 1;
+      unsigned destCallSignalAddressPresent : 1;
+      unsigned destExtraCallInfoPresent : 1;
+      unsigned srcCallSignalAddressPresent : 1;
+      unsigned nonStandardDataPresent : 1;
+      unsigned callServicesPresent : 1;
+      unsigned canMapAliasPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned srcAlternativesPresent : 1;
+      unsigned destAlternativesPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned transportQOSPresent : 1;
+      unsigned willSupplyUUIEsPresent : 1;
+      unsigned callLinkagePresent : 1;
+      unsigned gatewayDataRatePresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned desiredProtocolsPresent : 1;
+      unsigned desiredTunnelledProtocolPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+      unsigned canMapSrcAliasPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225CallType callType;
+   H225CallModel callModel;
+   H225EndpointIdentifier endpointIdentifier;
+   H225_SeqOfH225AliasAddress destinationInfo;
+   H225TransportAddress destCallSignalAddress;
+   H225_SeqOfH225AliasAddress destExtraCallInfo;
+   H225_SeqOfH225AliasAddress srcInfo;
+   H225TransportAddress srcCallSignalAddress;
+   H225BandWidth bandWidth;
+   H225CallReferenceValue callReferenceValue;
+   H225NonStandardParameter nonStandardData;
+   H225QseriesOptions callServices;
+   H225ConferenceIdentifier conferenceID;
+   ASN1BOOL activeMC;
+   ASN1BOOL answerCall;
+   ASN1BOOL canMapAlias;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225Endpoint srcAlternatives;
+   H225_SeqOfH225Endpoint destAlternatives;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225TransportQOS transportQOS;
+   ASN1BOOL willSupplyUUIEs;
+   H225CallLinkage callLinkage;
+   H225DataRate gatewayDataRate;
+   H225CallCapacity capacity;
+   H225CircuitInfo circuitInfo;
+   H225_SeqOfH225SupportedProtocols desiredProtocols;
+   H225TunnelledProtocol desiredTunnelledProtocol;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+   ASN1BOOL canMapSrcAlias;
+} H225AdmissionRequest;
+
+EXTERN int asn1PE_H225AdmissionRequest (OOCTXT* pctxt, H225AdmissionRequest* pvalue);
+
+EXTERN int asn1PD_H225AdmissionRequest (OOCTXT* pctxt, H225AdmissionRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UUIEsRequested                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225UUIEsRequested {
+   struct {
+      unsigned statusPresent : 1;
+      unsigned statusInquiryPresent : 1;
+      unsigned setupAcknowledgePresent : 1;
+      unsigned notifyPresent : 1;
+   } m;
+   ASN1BOOL setup;
+   ASN1BOOL callProceeding;
+   ASN1BOOL connect;
+   ASN1BOOL alerting;
+   ASN1BOOL information;
+   ASN1BOOL releaseComplete;
+   ASN1BOOL facility;
+   ASN1BOOL progress;
+   ASN1BOOL empty;
+   ASN1BOOL status;
+   ASN1BOOL statusInquiry;
+   ASN1BOOL setupAcknowledge;
+   ASN1BOOL notify;
+} H225UUIEsRequested;
+
+EXTERN int asn1PE_H225UUIEsRequested (OOCTXT* pctxt, H225UUIEsRequested* pvalue);
+
+EXTERN int asn1PD_H225UUIEsRequested (OOCTXT* pctxt, H225UUIEsRequested* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionConfirm_language                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225AdmissionConfirm_language {
+   ASN1UINT n;
+   ASN1IA5String *elem;
+} H225AdmissionConfirm_language;
+
+EXTERN int asn1PE_H225AdmissionConfirm_language (OOCTXT* pctxt, H225AdmissionConfirm_language* pvalue);
+
+EXTERN int asn1PD_H225AdmissionConfirm_language (OOCTXT* pctxt, H225AdmissionConfirm_language* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225AdmissionConfirm {
+   struct {
+      unsigned irrFrequencyPresent : 1;
+      unsigned nonStandardDataPresent : 1;
+      unsigned destinationInfoPresent : 1;
+      unsigned destExtraCallInfoPresent : 1;
+      unsigned destinationTypePresent : 1;
+      unsigned remoteExtensionAddressPresent : 1;
+      unsigned alternateEndpointsPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned transportQOSPresent : 1;
+      unsigned willRespondToIRRPresent : 1;
+      unsigned uuiesRequestedPresent : 1;
+      unsigned languagePresent : 1;
+      unsigned alternateTransportAddressesPresent : 1;
+      unsigned useSpecifiedTransportPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned usageSpecPresent : 1;
+      unsigned supportedProtocolsPresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+      unsigned modifiedSrcInfoPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225BandWidth bandWidth;
+   H225CallModel callModel;
+   H225TransportAddress destCallSignalAddress;
+   ASN1USINT irrFrequency;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225AliasAddress destinationInfo;
+   H225_SeqOfH225AliasAddress destExtraCallInfo;
+   H225EndpointType destinationType;
+   H225_SeqOfH225AliasAddress remoteExtensionAddress;
+   H225_SeqOfH225Endpoint alternateEndpoints;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225TransportQOS transportQOS;
+   ASN1BOOL willRespondToIRR;
+   H225UUIEsRequested uuiesRequested;
+   H225AdmissionConfirm_language language;
+   H225AlternateTransportAddresses alternateTransportAddresses;
+   H225UseSpecifiedTransport useSpecifiedTransport;
+   H225CircuitInfo circuitInfo;
+   H225_SeqOfH225RasUsageSpecification usageSpec;
+   H225_SeqOfH225SupportedProtocols supportedProtocols;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   ASN1BOOL multipleCalls;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+   H225_SeqOfH225AliasAddress modifiedSrcInfo;
+} H225AdmissionConfirm;
+
+EXTERN int asn1PE_H225AdmissionConfirm (OOCTXT* pctxt, H225AdmissionConfirm* pvalue);
+
+EXTERN int asn1PD_H225AdmissionConfirm (OOCTXT* pctxt, H225AdmissionConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225PartyNumber                                     */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225PartyNumber */
+typedef DList H225_SeqOfH225PartyNumber;
+
+EXTERN int asn1PE_H225_SeqOfH225PartyNumber (OOCTXT* pctxt, H225_SeqOfH225PartyNumber* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225PartyNumber (OOCTXT* pctxt, H225_SeqOfH225PartyNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionRejectReason                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225AdmissionRejectReason_calledPartyNotRegistered 1
+#define T_H225AdmissionRejectReason_invalidPermission 2
+#define T_H225AdmissionRejectReason_requestDenied 3
+#define T_H225AdmissionRejectReason_undefinedReason 4
+#define T_H225AdmissionRejectReason_callerNotRegistered 5
+#define T_H225AdmissionRejectReason_routeCallToGatekeeper 6
+#define T_H225AdmissionRejectReason_invalidEndpointIdentifier 7
+#define T_H225AdmissionRejectReason_resourceUnavailable 8
+#define T_H225AdmissionRejectReason_securityDenial 9
+#define T_H225AdmissionRejectReason_qosControlNotSupported 10
+#define T_H225AdmissionRejectReason_incompleteAddress 11
+#define T_H225AdmissionRejectReason_aliasesInconsistent 12
+#define T_H225AdmissionRejectReason_routeCallToSCN 13
+#define T_H225AdmissionRejectReason_exceedsCallCapacity 14
+#define T_H225AdmissionRejectReason_collectDestination 15
+#define T_H225AdmissionRejectReason_collectPIN 16
+#define T_H225AdmissionRejectReason_genericDataReason 17
+#define T_H225AdmissionRejectReason_neededFeatureNotSupported 18
+#define T_H225AdmissionRejectReason_securityErrors 19
+#define T_H225AdmissionRejectReason_securityDHmismatch 20
+#define T_H225AdmissionRejectReason_noRouteToDestination 21
+#define T_H225AdmissionRejectReason_unallocatedNumber 22
+#define T_H225AdmissionRejectReason_extElem1 23
+
+typedef struct EXTERN H225AdmissionRejectReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      /* t = 9 */
+      /* t = 10 */
+      /* t = 11 */
+      /* t = 12 */
+      /* t = 13 */
+      H225_SeqOfH225PartyNumber *routeCallToSCN;
+      /* t = 14 */
+      /* t = 15 */
+      /* t = 16 */
+      /* t = 17 */
+      /* t = 18 */
+      /* t = 19 */
+      H225SecurityErrors2 *securityErrors;
+      /* t = 20 */
+      /* t = 21 */
+      /* t = 22 */
+      /* t = 23 */
+   } u;
+} H225AdmissionRejectReason;
+
+EXTERN int asn1PE_H225AdmissionRejectReason (OOCTXT* pctxt, H225AdmissionRejectReason* pvalue);
+
+EXTERN int asn1PD_H225AdmissionRejectReason (OOCTXT* pctxt, H225AdmissionRejectReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionReject                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225AdmissionReject {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned altGKInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned callSignalAddressPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225AdmissionRejectReason rejectReason;
+   H225NonStandardParameter nonStandardData;
+   H225AltGKInfo altGKInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225_SeqOfH225TransportAddress callSignalAddress;
+   H225ICV integrityCheckValue;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225AdmissionReject;
+
+EXTERN int asn1PE_H225AdmissionReject (OOCTXT* pctxt, H225AdmissionReject* pvalue);
+
+EXTERN int asn1PD_H225AdmissionReject (OOCTXT* pctxt, H225AdmissionReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225BandwidthDetails                                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225BandwidthDetails */
+typedef DList H225_SeqOfH225BandwidthDetails;
+
+EXTERN int asn1PE_H225_SeqOfH225BandwidthDetails (OOCTXT* pctxt, H225_SeqOfH225BandwidthDetails* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225BandwidthDetails (OOCTXT* pctxt, H225_SeqOfH225BandwidthDetails* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225BandwidthRequest {
+   struct {
+      unsigned callTypePresent : 1;
+      unsigned nonStandardDataPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned answeredCallPresent : 1;
+      unsigned callLinkagePresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned usageInformationPresent : 1;
+      unsigned bandwidthDetailsPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225EndpointIdentifier endpointIdentifier;
+   H225ConferenceIdentifier conferenceID;
+   H225CallReferenceValue callReferenceValue;
+   H225CallType callType;
+   H225BandWidth bandWidth;
+   H225NonStandardParameter nonStandardData;
+   H225CallIdentifier callIdentifier;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   ASN1BOOL answeredCall;
+   H225CallLinkage callLinkage;
+   H225CallCapacity capacity;
+   H225RasUsageInformation usageInformation;
+   H225_SeqOfH225BandwidthDetails bandwidthDetails;
+   H225_SeqOfH225GenericData genericData;
+} H225BandwidthRequest;
+
+EXTERN int asn1PE_H225BandwidthRequest (OOCTXT* pctxt, H225BandwidthRequest* pvalue);
+
+EXTERN int asn1PD_H225BandwidthRequest (OOCTXT* pctxt, H225BandwidthRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225BandwidthConfirm {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225BandWidth bandWidth;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225CallCapacity capacity;
+   H225_SeqOfH225GenericData genericData;
+} H225BandwidthConfirm;
+
+EXTERN int asn1PE_H225BandwidthConfirm (OOCTXT* pctxt, H225BandwidthConfirm* pvalue);
+
+EXTERN int asn1PD_H225BandwidthConfirm (OOCTXT* pctxt, H225BandwidthConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  BandRejectReason                                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225BandRejectReason_notBound 1
+#define T_H225BandRejectReason_invalidConferenceID 2
+#define T_H225BandRejectReason_invalidPermission 3
+#define T_H225BandRejectReason_insufficientResources 4
+#define T_H225BandRejectReason_invalidRevision 5
+#define T_H225BandRejectReason_undefinedReason 6
+#define T_H225BandRejectReason_securityDenial 7
+#define T_H225BandRejectReason_securityError 8
+#define T_H225BandRejectReason_extElem1 9
+
+typedef struct EXTERN H225BandRejectReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      H225SecurityErrors2 *securityError;
+      /* t = 9 */
+   } u;
+} H225BandRejectReason;
+
+EXTERN int asn1PE_H225BandRejectReason (OOCTXT* pctxt, H225BandRejectReason* pvalue);
+
+EXTERN int asn1PD_H225BandRejectReason (OOCTXT* pctxt, H225BandRejectReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthReject                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225BandwidthReject {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned altGKInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225BandRejectReason rejectReason;
+   H225BandWidth allowedBandWidth;
+   H225NonStandardParameter nonStandardData;
+   H225AltGKInfo altGKInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225_SeqOfH225GenericData genericData;
+} H225BandwidthReject;
+
+EXTERN int asn1PE_H225BandwidthReject (OOCTXT* pctxt, H225BandwidthReject* pvalue);
+
+EXTERN int asn1PD_H225BandwidthReject (OOCTXT* pctxt, H225BandwidthReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageReason                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225DisengageReason_forcedDrop 1
+#define T_H225DisengageReason_normalDrop 2
+#define T_H225DisengageReason_undefinedReason 3
+#define T_H225DisengageReason_extElem1  4
+
+typedef struct EXTERN H225DisengageReason {
+   int t;
+} H225DisengageReason;
+
+EXTERN int asn1PE_H225DisengageReason (OOCTXT* pctxt, H225DisengageReason* pvalue);
+
+EXTERN int asn1PD_H225DisengageReason (OOCTXT* pctxt, H225DisengageReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225DisengageRequest {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned answeredCallPresent : 1;
+      unsigned callLinkagePresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned usageInformationPresent : 1;
+      unsigned terminationCausePresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225EndpointIdentifier endpointIdentifier;
+   H225ConferenceIdentifier conferenceID;
+   H225CallReferenceValue callReferenceValue;
+   H225DisengageReason disengageReason;
+   H225NonStandardParameter nonStandardData;
+   H225CallIdentifier callIdentifier;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   ASN1BOOL answeredCall;
+   H225CallLinkage callLinkage;
+   H225CallCapacity capacity;
+   H225CircuitInfo circuitInfo;
+   H225RasUsageInformation usageInformation;
+   H225CallTerminationCause terminationCause;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225_SeqOfH225GenericData genericData;
+} H225DisengageRequest;
+
+EXTERN int asn1PE_H225DisengageRequest (OOCTXT* pctxt, H225DisengageRequest* pvalue);
+
+EXTERN int asn1PD_H225DisengageRequest (OOCTXT* pctxt, H225DisengageRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225DisengageConfirm {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned usageInformationPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225CallCapacity capacity;
+   H225CircuitInfo circuitInfo;
+   H225RasUsageInformation usageInformation;
+   H225_SeqOfH225GenericData genericData;
+} H225DisengageConfirm;
+
+EXTERN int asn1PE_H225DisengageConfirm (OOCTXT* pctxt, H225DisengageConfirm* pvalue);
+
+EXTERN int asn1PD_H225DisengageConfirm (OOCTXT* pctxt, H225DisengageConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageRejectReason                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225DisengageRejectReason_notRegistered 1
+#define T_H225DisengageRejectReason_requestToDropOther 2
+#define T_H225DisengageRejectReason_securityDenial 3
+#define T_H225DisengageRejectReason_securityError 4
+#define T_H225DisengageRejectReason_extElem1 5
+
+typedef struct EXTERN H225DisengageRejectReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      H225SecurityErrors2 *securityError;
+      /* t = 5 */
+   } u;
+} H225DisengageRejectReason;
+
+EXTERN int asn1PE_H225DisengageRejectReason (OOCTXT* pctxt, H225DisengageRejectReason* pvalue);
+
+EXTERN int asn1PD_H225DisengageRejectReason (OOCTXT* pctxt, H225DisengageRejectReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageReject                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225DisengageReject {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned altGKInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225DisengageRejectReason rejectReason;
+   H225NonStandardParameter nonStandardData;
+   H225AltGKInfo altGKInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225_SeqOfH225GenericData genericData;
+} H225DisengageReject;
+
+EXTERN int asn1PE_H225DisengageReject (OOCTXT* pctxt, H225DisengageReject* pvalue);
+
+EXTERN int asn1PD_H225DisengageReject (OOCTXT* pctxt, H225DisengageReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LocationRequest                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225LocationRequest {
+   struct {
+      unsigned endpointIdentifierPresent : 1;
+      unsigned nonStandardDataPresent : 1;
+      unsigned sourceInfoPresent : 1;
+      unsigned canMapAliasPresent : 1;
+      unsigned gatekeeperIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned desiredProtocolsPresent : 1;
+      unsigned desiredTunnelledProtocolPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+      unsigned hopCountPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned bandWidthPresent : 1;
+      unsigned sourceEndpointInfoPresent : 1;
+      unsigned canMapSrcAliasPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225EndpointIdentifier endpointIdentifier;
+   H225_SeqOfH225AliasAddress destinationInfo;
+   H225NonStandardParameter nonStandardData;
+   H225TransportAddress replyAddress;
+   H225_SeqOfH225AliasAddress sourceInfo;
+   ASN1BOOL canMapAlias;
+   H225GatekeeperIdentifier gatekeeperIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225_SeqOfH225SupportedProtocols desiredProtocols;
+   H225TunnelledProtocol desiredTunnelledProtocol;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+   ASN1UINT8 hopCount;
+   H225CircuitInfo circuitInfo;
+   H225CallIdentifier callIdentifier;
+   H225BandWidth bandWidth;
+   H225_SeqOfH225AliasAddress sourceEndpointInfo;
+   ASN1BOOL canMapSrcAlias;
+} H225LocationRequest;
+
+EXTERN int asn1PE_H225LocationRequest (OOCTXT* pctxt, H225LocationRequest* pvalue);
+
+EXTERN int asn1PD_H225LocationRequest (OOCTXT* pctxt, H225LocationRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LocationConfirm                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225LocationConfirm {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned destinationInfoPresent : 1;
+      unsigned destExtraCallInfoPresent : 1;
+      unsigned destinationTypePresent : 1;
+      unsigned remoteExtensionAddressPresent : 1;
+      unsigned alternateEndpointsPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned alternateTransportAddressesPresent : 1;
+      unsigned supportedProtocolsPresent : 1;
+      unsigned multipleCallsPresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+      unsigned circuitInfoPresent : 1;
+      unsigned serviceControlPresent : 1;
+      unsigned modifiedSrcInfoPresent : 1;
+      unsigned bandWidthPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225TransportAddress callSignalAddress;
+   H225TransportAddress rasAddress;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225AliasAddress destinationInfo;
+   H225_SeqOfH225AliasAddress destExtraCallInfo;
+   H225EndpointType destinationType;
+   H225_SeqOfH225AliasAddress remoteExtensionAddress;
+   H225_SeqOfH225Endpoint alternateEndpoints;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225AlternateTransportAddresses alternateTransportAddresses;
+   H225_SeqOfH225SupportedProtocols supportedProtocols;
+   ASN1BOOL multipleCalls;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+   H225CircuitInfo circuitInfo;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225_SeqOfH225AliasAddress modifiedSrcInfo;
+   H225BandWidth bandWidth;
+} H225LocationConfirm;
+
+EXTERN int asn1PE_H225LocationConfirm (OOCTXT* pctxt, H225LocationConfirm* pvalue);
+
+EXTERN int asn1PD_H225LocationConfirm (OOCTXT* pctxt, H225LocationConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LocationRejectReason                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225LocationRejectReason_notRegistered 1
+#define T_H225LocationRejectReason_invalidPermission 2
+#define T_H225LocationRejectReason_requestDenied 3
+#define T_H225LocationRejectReason_undefinedReason 4
+#define T_H225LocationRejectReason_securityDenial 5
+#define T_H225LocationRejectReason_aliasesInconsistent 6
+#define T_H225LocationRejectReason_routeCalltoSCN 7
+#define T_H225LocationRejectReason_resourceUnavailable 8
+#define T_H225LocationRejectReason_genericDataReason 9
+#define T_H225LocationRejectReason_neededFeatureNotSupported 10
+#define T_H225LocationRejectReason_hopCountExceeded 11
+#define T_H225LocationRejectReason_incompleteAddress 12
+#define T_H225LocationRejectReason_securityError 13
+#define T_H225LocationRejectReason_securityDHmismatch 14
+#define T_H225LocationRejectReason_noRouteToDestination 15
+#define T_H225LocationRejectReason_unallocatedNumber 16
+#define T_H225LocationRejectReason_extElem1 17
+
+typedef struct EXTERN H225LocationRejectReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      H225_SeqOfH225PartyNumber *routeCalltoSCN;
+      /* t = 8 */
+      /* t = 9 */
+      /* t = 10 */
+      /* t = 11 */
+      /* t = 12 */
+      /* t = 13 */
+      H225SecurityErrors2 *securityError;
+      /* t = 14 */
+      /* t = 15 */
+      /* t = 16 */
+      /* t = 17 */
+   } u;
+} H225LocationRejectReason;
+
+EXTERN int asn1PE_H225LocationRejectReason (OOCTXT* pctxt, H225LocationRejectReason* pvalue);
+
+EXTERN int asn1PD_H225LocationRejectReason (OOCTXT* pctxt, H225LocationRejectReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LocationReject                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225LocationReject {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned altGKInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+      unsigned serviceControlPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225LocationRejectReason rejectReason;
+   H225NonStandardParameter nonStandardData;
+   H225AltGKInfo altGKInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+} H225LocationReject;
+
+EXTERN int asn1PE_H225LocationReject (OOCTXT* pctxt, H225LocationReject* pvalue);
+
+EXTERN int asn1PD_H225LocationReject (OOCTXT* pctxt, H225LocationReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequest                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225InfoRequest {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned replyAddressPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned uuiesRequestedPresent : 1;
+      unsigned callLinkagePresent : 1;
+      unsigned usageInfoRequestedPresent : 1;
+      unsigned segmentedResponseSupportedPresent : 1;
+      unsigned nextSegmentRequestedPresent : 1;
+      unsigned capacityInfoRequestedPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225CallReferenceValue callReferenceValue;
+   H225NonStandardParameter nonStandardData;
+   H225TransportAddress replyAddress;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225UUIEsRequested uuiesRequested;
+   H225CallLinkage callLinkage;
+   H225RasUsageInfoTypes usageInfoRequested;
+   ASN1USINT nextSegmentRequested;
+   H225_SeqOfH225GenericData genericData;
+} H225InfoRequest;
+
+EXTERN int asn1PE_H225InfoRequest (OOCTXT* pctxt, H225InfoRequest* pvalue);
+
+EXTERN int asn1PD_H225InfoRequest (OOCTXT* pctxt, H225InfoRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225RTPSession                                      */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225RTPSession */
+typedef DList H225_SeqOfH225RTPSession;
+
+EXTERN int asn1PE_H225_SeqOfH225RTPSession (OOCTXT* pctxt, H225_SeqOfH225RTPSession* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225RTPSession (OOCTXT* pctxt, H225_SeqOfH225RTPSession* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportChannelInfo                            */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225TransportChannelInfo */
+typedef DList H225_SeqOfH225TransportChannelInfo;
+
+EXTERN int asn1PE_H225_SeqOfH225TransportChannelInfo (OOCTXT* pctxt, H225_SeqOfH225TransportChannelInfo* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225TransportChannelInfo (OOCTXT* pctxt, H225_SeqOfH225TransportChannelInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ConferenceIdentifier                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225_SeqOfH225ConferenceIdentifier {
+   ASN1UINT n;
+   H225ConferenceIdentifier *elem;
+} H225_SeqOfH225ConferenceIdentifier;
+
+EXTERN int asn1PE_H225_SeqOfH225ConferenceIdentifier (OOCTXT* pctxt, H225_SeqOfH225ConferenceIdentifier* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225ConferenceIdentifier (OOCTXT* pctxt, H225_SeqOfH225ConferenceIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse_perCallInfo_element_pdu_element       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225InfoRequestResponse_perCallInfo_element_pdu_element {
+   H225H323_UU_PDU h323pdu;
+   ASN1BOOL sent;
+} H225InfoRequestResponse_perCallInfo_element_pdu_element;
+
+EXTERN int asn1PE_H225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue);
+
+EXTERN int asn1PD_H225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_el  */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225InfoRequestResponse_perCallInfo_element_pdu_element */
+typedef DList H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element;
+
+EXTERN int asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse_perCallInfo_element                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225InfoRequestResponse_perCallInfo_element {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned originatorPresent : 1;
+      unsigned audioPresent : 1;
+      unsigned videoPresent : 1;
+      unsigned dataPresent : 1;
+      unsigned callIdentifierPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned substituteConfIDsPresent : 1;
+      unsigned pduPresent : 1;
+      unsigned callLinkagePresent : 1;
+      unsigned usageInformationPresent : 1;
+      unsigned circuitInfoPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225CallReferenceValue callReferenceValue;
+   H225ConferenceIdentifier conferenceID;
+   ASN1BOOL originator;
+   H225_SeqOfH225RTPSession audio;
+   H225_SeqOfH225RTPSession video;
+   H225_SeqOfH225TransportChannelInfo data;
+   H225TransportChannelInfo h245;
+   H225TransportChannelInfo callSignaling;
+   H225CallType callType;
+   H225BandWidth bandWidth;
+   H225CallModel callModel;
+   H225CallIdentifier callIdentifier;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225_SeqOfH225ConferenceIdentifier substituteConfIDs;
+   H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element pdu;
+   H225CallLinkage callLinkage;
+   H225RasUsageInformation usageInformation;
+   H225CircuitInfo circuitInfo;
+} H225InfoRequestResponse_perCallInfo_element;
+
+EXTERN int asn1PE_H225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element* pvalue);
+
+EXTERN int asn1PD_H225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225InfoRequestResponse_perCallInfo_element         */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225InfoRequestResponse_perCallInfo_element */
+typedef DList H225_SeqOfH225InfoRequestResponse_perCallInfo_element;
+
+EXTERN int asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponseStatus                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225InfoRequestResponseStatus_complete 1
+#define T_H225InfoRequestResponseStatus_incomplete 2
+#define T_H225InfoRequestResponseStatus_segment 3
+#define T_H225InfoRequestResponseStatus_invalidCall 4
+#define T_H225InfoRequestResponseStatus_extElem1 5
+
+typedef struct EXTERN H225InfoRequestResponseStatus {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      ASN1USINT segment;
+      /* t = 4 */
+      /* t = 5 */
+   } u;
+} H225InfoRequestResponseStatus;
+
+EXTERN int asn1PE_H225InfoRequestResponseStatus (OOCTXT* pctxt, H225InfoRequestResponseStatus* pvalue);
+
+EXTERN int asn1PD_H225InfoRequestResponseStatus (OOCTXT* pctxt, H225InfoRequestResponseStatus* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225InfoRequestResponse {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned endpointAliasPresent : 1;
+      unsigned perCallInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned needResponsePresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned irrStatusPresent : 1;
+      unsigned unsolicitedPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225NonStandardParameter nonStandardData;
+   H225RequestSeqNum requestSeqNum;
+   H225EndpointType endpointType;
+   H225EndpointIdentifier endpointIdentifier;
+   H225TransportAddress rasAddress;
+   H225_SeqOfH225TransportAddress callSignalAddress;
+   H225_SeqOfH225AliasAddress endpointAlias;
+   H225_SeqOfH225InfoRequestResponse_perCallInfo_element perCallInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   ASN1BOOL needResponse;
+   H225CallCapacity capacity;
+   H225InfoRequestResponseStatus irrStatus;
+   ASN1BOOL unsolicited;
+   H225_SeqOfH225GenericData genericData;
+} H225InfoRequestResponse;
+
+EXTERN int asn1PE_H225InfoRequestResponse (OOCTXT* pctxt, H225InfoRequestResponse* pvalue);
+
+EXTERN int asn1PD_H225InfoRequestResponse (OOCTXT* pctxt, H225InfoRequestResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardMessage                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225NonStandardMessage {
+   struct {
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225NonStandardMessage;
+
+EXTERN int asn1PE_H225NonStandardMessage (OOCTXT* pctxt, H225NonStandardMessage* pvalue);
+
+EXTERN int asn1PD_H225NonStandardMessage (OOCTXT* pctxt, H225NonStandardMessage* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnknownMessageResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225UnknownMessageResponse {
+   struct {
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned messageNotUnderstoodPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   ASN1DynOctStr messageNotUnderstood;
+} H225UnknownMessageResponse;
+
+EXTERN int asn1PE_H225UnknownMessageResponse (OOCTXT* pctxt, H225UnknownMessageResponse* pvalue);
+
+EXTERN int asn1PD_H225UnknownMessageResponse (OOCTXT* pctxt, H225UnknownMessageResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestInProgress                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225RequestInProgress {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   ASN1USINT delay;
+} H225RequestInProgress;
+
+EXTERN int asn1PE_H225RequestInProgress (OOCTXT* pctxt, H225RequestInProgress* pvalue);
+
+EXTERN int asn1PD_H225RequestInProgress (OOCTXT* pctxt, H225RequestInProgress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ResourcesAvailableIndicate                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ResourcesAvailableIndicate {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned capacityPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225NonStandardParameter nonStandardData;
+   H225EndpointIdentifier endpointIdentifier;
+   H225_SeqOfH225SupportedProtocols protocols;
+   ASN1BOOL almostOutOfResources;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225CallCapacity capacity;
+   H225_SeqOfH225GenericData genericData;
+} H225ResourcesAvailableIndicate;
+
+EXTERN int asn1PE_H225ResourcesAvailableIndicate (OOCTXT* pctxt, H225ResourcesAvailableIndicate* pvalue);
+
+EXTERN int asn1PD_H225ResourcesAvailableIndicate (OOCTXT* pctxt, H225ResourcesAvailableIndicate* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ResourcesAvailableConfirm                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ResourcesAvailableConfirm {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ProtocolIdentifier protocolIdentifier;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225_SeqOfH225GenericData genericData;
+} H225ResourcesAvailableConfirm;
+
+EXTERN int asn1PE_H225ResourcesAvailableConfirm (OOCTXT* pctxt, H225ResourcesAvailableConfirm* pvalue);
+
+EXTERN int asn1PD_H225ResourcesAvailableConfirm (OOCTXT* pctxt, H225ResourcesAvailableConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestAck                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225InfoRequestAck {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+} H225InfoRequestAck;
+
+EXTERN int asn1PE_H225InfoRequestAck (OOCTXT* pctxt, H225InfoRequestAck* pvalue);
+
+EXTERN int asn1PD_H225InfoRequestAck (OOCTXT* pctxt, H225InfoRequestAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestNakReason                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225InfoRequestNakReason_notRegistered 1
+#define T_H225InfoRequestNakReason_securityDenial 2
+#define T_H225InfoRequestNakReason_undefinedReason 3
+#define T_H225InfoRequestNakReason_securityError 4
+#define T_H225InfoRequestNakReason_extElem1 5
+
+typedef struct EXTERN H225InfoRequestNakReason {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      H225SecurityErrors2 *securityError;
+      /* t = 5 */
+   } u;
+} H225InfoRequestNakReason;
+
+EXTERN int asn1PE_H225InfoRequestNakReason (OOCTXT* pctxt, H225InfoRequestNakReason* pvalue);
+
+EXTERN int asn1PD_H225InfoRequestNakReason (OOCTXT* pctxt, H225InfoRequestNakReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestNak                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225InfoRequestNak {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned altGKInfoPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225NonStandardParameter nonStandardData;
+   H225InfoRequestNakReason nakReason;
+   H225AltGKInfo altGKInfo;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+} H225InfoRequestNak;
+
+EXTERN int asn1PE_H225InfoRequestNak (OOCTXT* pctxt, H225InfoRequestNak* pvalue);
+
+EXTERN int asn1PD_H225InfoRequestNak (OOCTXT* pctxt, H225InfoRequestNak* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlIndication_callSpecific                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ServiceControlIndication_callSpecific {
+   H225CallIdentifier callIdentifier;
+   H225ConferenceIdentifier conferenceID;
+   ASN1BOOL answeredCall;
+} H225ServiceControlIndication_callSpecific;
+
+EXTERN int asn1PE_H225ServiceControlIndication_callSpecific (OOCTXT* pctxt, H225ServiceControlIndication_callSpecific* pvalue);
+
+EXTERN int asn1PD_H225ServiceControlIndication_callSpecific (OOCTXT* pctxt, H225ServiceControlIndication_callSpecific* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlIndication                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ServiceControlIndication {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned endpointIdentifierPresent : 1;
+      unsigned callSpecificPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ServiceControlSession serviceControl;
+   H225EndpointIdentifier endpointIdentifier;
+   H225ServiceControlIndication_callSpecific callSpecific;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225ServiceControlIndication;
+
+EXTERN int asn1PE_H225ServiceControlIndication (OOCTXT* pctxt, H225ServiceControlIndication* pvalue);
+
+EXTERN int asn1PD_H225ServiceControlIndication (OOCTXT* pctxt, H225ServiceControlIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlResponse_result                             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225ServiceControlResponse_result_started 1
+#define T_H225ServiceControlResponse_result_failed 2
+#define T_H225ServiceControlResponse_result_stopped 3
+#define T_H225ServiceControlResponse_result_notAvailable 4
+#define T_H225ServiceControlResponse_result_neededFeatureNotSupported 5
+#define T_H225ServiceControlResponse_result_extElem1 6
+
+typedef struct EXTERN H225ServiceControlResponse_result {
+   int t;
+} H225ServiceControlResponse_result;
+
+EXTERN int asn1PE_H225ServiceControlResponse_result (OOCTXT* pctxt, H225ServiceControlResponse_result* pvalue);
+
+EXTERN int asn1PD_H225ServiceControlResponse_result (OOCTXT* pctxt, H225ServiceControlResponse_result* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H225ServiceControlResponse {
+   struct {
+      unsigned resultPresent : 1;
+      unsigned nonStandardDataPresent : 1;
+      unsigned tokensPresent : 1;
+      unsigned cryptoTokensPresent : 1;
+      unsigned integrityCheckValuePresent : 1;
+      unsigned featureSetPresent : 1;
+      unsigned genericDataPresent : 1;
+   } m;
+   H225RequestSeqNum requestSeqNum;
+   H225ServiceControlResponse_result result;
+   H225NonStandardParameter nonStandardData;
+   H225_SeqOfH225ClearToken tokens;
+   H225_SeqOfH225CryptoH323Token cryptoTokens;
+   H225ICV integrityCheckValue;
+   H225FeatureSet featureSet;
+   H225_SeqOfH225GenericData genericData;
+} H225ServiceControlResponse;
+
+EXTERN int asn1PE_H225ServiceControlResponse (OOCTXT* pctxt, H225ServiceControlResponse* pvalue);
+
+EXTERN int asn1PD_H225ServiceControlResponse (OOCTXT* pctxt, H225ServiceControlResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AdmissionConfirm                                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H225AdmissionConfirm */
+typedef DList H225_SeqOfH225AdmissionConfirm;
+
+EXTERN int asn1PE_H225_SeqOfH225AdmissionConfirm (OOCTXT* pctxt, H225_SeqOfH225AdmissionConfirm* pvalue);
+
+EXTERN int asn1PD_H225_SeqOfH225AdmissionConfirm (OOCTXT* pctxt, H225_SeqOfH225AdmissionConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RasMessage                                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H225RasMessage_gatekeeperRequest 1
+#define T_H225RasMessage_gatekeeperConfirm 2
+#define T_H225RasMessage_gatekeeperReject 3
+#define T_H225RasMessage_registrationRequest 4
+#define T_H225RasMessage_registrationConfirm 5
+#define T_H225RasMessage_registrationReject 6
+#define T_H225RasMessage_unregistrationRequest 7
+#define T_H225RasMessage_unregistrationConfirm 8
+#define T_H225RasMessage_unregistrationReject 9
+#define T_H225RasMessage_admissionRequest 10
+#define T_H225RasMessage_admissionConfirm 11
+#define T_H225RasMessage_admissionReject 12
+#define T_H225RasMessage_bandwidthRequest 13
+#define T_H225RasMessage_bandwidthConfirm 14
+#define T_H225RasMessage_bandwidthReject 15
+#define T_H225RasMessage_disengageRequest 16
+#define T_H225RasMessage_disengageConfirm 17
+#define T_H225RasMessage_disengageReject 18
+#define T_H225RasMessage_locationRequest 19
+#define T_H225RasMessage_locationConfirm 20
+#define T_H225RasMessage_locationReject 21
+#define T_H225RasMessage_infoRequest    22
+#define T_H225RasMessage_infoRequestResponse 23
+#define T_H225RasMessage_nonStandardMessage 24
+#define T_H225RasMessage_unknownMessageResponse 25
+#define T_H225RasMessage_requestInProgress 26
+#define T_H225RasMessage_resourcesAvailableIndicate 27
+#define T_H225RasMessage_resourcesAvailableConfirm 28
+#define T_H225RasMessage_infoRequestAck 29
+#define T_H225RasMessage_infoRequestNak 30
+#define T_H225RasMessage_serviceControlIndication 31
+#define T_H225RasMessage_serviceControlResponse 32
+#define T_H225RasMessage_admissionConfirmSequence 33
+#define T_H225RasMessage_extElem1       34
+
+typedef struct EXTERN H225RasMessage {
+   int t;
+   union {
+      /* t = 1 */
+      H225GatekeeperRequest *gatekeeperRequest;
+      /* t = 2 */
+      H225GatekeeperConfirm *gatekeeperConfirm;
+      /* t = 3 */
+      H225GatekeeperReject *gatekeeperReject;
+      /* t = 4 */
+      H225RegistrationRequest *registrationRequest;
+      /* t = 5 */
+      H225RegistrationConfirm *registrationConfirm;
+      /* t = 6 */
+      H225RegistrationReject *registrationReject;
+      /* t = 7 */
+      H225UnregistrationRequest *unregistrationRequest;
+      /* t = 8 */
+      H225UnregistrationConfirm *unregistrationConfirm;
+      /* t = 9 */
+      H225UnregistrationReject *unregistrationReject;
+      /* t = 10 */
+      H225AdmissionRequest *admissionRequest;
+      /* t = 11 */
+      H225AdmissionConfirm *admissionConfirm;
+      /* t = 12 */
+      H225AdmissionReject *admissionReject;
+      /* t = 13 */
+      H225BandwidthRequest *bandwidthRequest;
+      /* t = 14 */
+      H225BandwidthConfirm *bandwidthConfirm;
+      /* t = 15 */
+      H225BandwidthReject *bandwidthReject;
+      /* t = 16 */
+      H225DisengageRequest *disengageRequest;
+      /* t = 17 */
+      H225DisengageConfirm *disengageConfirm;
+      /* t = 18 */
+      H225DisengageReject *disengageReject;
+      /* t = 19 */
+      H225LocationRequest *locationRequest;
+      /* t = 20 */
+      H225LocationConfirm *locationConfirm;
+      /* t = 21 */
+      H225LocationReject *locationReject;
+      /* t = 22 */
+      H225InfoRequest *infoRequest;
+      /* t = 23 */
+      H225InfoRequestResponse *infoRequestResponse;
+      /* t = 24 */
+      H225NonStandardMessage *nonStandardMessage;
+      /* t = 25 */
+      H225UnknownMessageResponse *unknownMessageResponse;
+      /* t = 26 */
+      H225RequestInProgress *requestInProgress;
+      /* t = 27 */
+      H225ResourcesAvailableIndicate *resourcesAvailableIndicate;
+      /* t = 28 */
+      H225ResourcesAvailableConfirm *resourcesAvailableConfirm;
+      /* t = 29 */
+      H225InfoRequestAck *infoRequestAck;
+      /* t = 30 */
+      H225InfoRequestNak *infoRequestNak;
+      /* t = 31 */
+      H225ServiceControlIndication *serviceControlIndication;
+      /* t = 32 */
+      H225ServiceControlResponse *serviceControlResponse;
+      /* t = 33 */
+      H225_SeqOfH225AdmissionConfirm *admissionConfirmSequence;
+      /* t = 34 */
+   } u;
+} H225RasMessage;
+
+EXTERN int asn1PE_H225RasMessage (OOCTXT* pctxt, H225RasMessage* pvalue);
+
+EXTERN int asn1PD_H225RasMessage (OOCTXT* pctxt, H225RasMessage* pvalue);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/h323/H323-MESSAGESDec.c b/addons/ooh323c/src/h323/H323-MESSAGESDec.c
new file mode 100644
index 000000000..2f8700b66
--- /dev/null
+++ b/addons/ooh323c/src/h323/H323-MESSAGESDec.c
@@ -0,0 +1,27199 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooasn1.h"
+#include "H323-MESSAGES.h"
+#include "eventHandler.h"
+
+/**************************************************************/
+/*                                                            */
+/*  ScreeningIndicator                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+
+      *pvalue = ui;
+   }
+   else {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      switch (ui) {
+         case 0: *pvalue = userProvidedNotScreened; break;
+         case 1: *pvalue = userProvidedVerifiedAndPassed; break;
+         case 2: *pvalue = userProvidedVerifiedAndFailed; break;
+         case 3: *pvalue = networkProvided; break;
+         default: return ASN_E_INVENUM;
+      }
+   }
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NumberDigits                                              */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_NumberDigits_CharSet;
+
+EXTERN int asn1PD_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeConstrainedStringEx (pctxt, pvalue, gs_H323_MESSAGES_NumberDigits_CharSet, 4, 4, 7);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TBCD_STRING                                               */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_TBCD_STRING_CharSet;
+
+EXTERN int asn1PD_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConstrainedStringEx (pctxt, pvalue, gs_H323_MESSAGES_TBCD_STRING_CharSet, 4, 4, 7);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GloballyUniqueID                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = asn1PD_H225GloballyUniqueID (pctxt, pvalue);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestSeqNum                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt16 (pctxt, pvalue, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBMPString (pctxt, pvalue, 0);
+   if (stat != ASN_OK) return stat;
+   invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandWidth                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225BandWidth (OOCTXT* pctxt, H225BandWidth* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUnsigned (pctxt, pvalue, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallReferenceValue                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt16 (pctxt, pvalue, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointIdentifier                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBMPString (pctxt, pvalue, 0);
+   if (stat != ASN_OK) return stat;
+   invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ProtocolIdentifier                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeObjectIdentifier (pctxt, pvalue);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->numids, pvalue->subid);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TimeToLive                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUnsigned (pctxt, pvalue, 1U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H248PackagesDescriptor                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H248SignalsDescriptor                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericIdentifier                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* standard */
+         case 0:
+            invokeStartElement (pctxt, "standard", -1);
+
+            /* extension bit */
+
+            DECODEBIT (pctxt, &extbit);
+
+            if (extbit == 0) {
+               stat = decodeConsInteger (pctxt, &pvalue->u.standard, 0, 16383);
+               if (stat != ASN_OK) return stat;
+            }
+            else {
+               stat = decodeUnconsInteger (pctxt, &pvalue->u.standard);
+               if (stat != ASN_OK) return stat;
+            }
+            invokeIntValue (pctxt, pvalue->u.standard);
+
+            invokeEndElement (pctxt, "standard", -1);
+
+            break;
+
+         /* oid */
+         case 1:
+            invokeStartElement (pctxt, "oid", -1);
+
+            pvalue->u.oid = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.oid);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.oid->numids, pvalue->u.oid->subid);
+
+            invokeEndElement (pctxt, "oid", -1);
+
+            break;
+
+         /* nonStandard */
+         case 2:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225GloballyUniqueID);
+
+            stat = asn1PD_H225GloballyUniqueID (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipAddress_ip                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipAddress                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode ip */
+
+   invokeStartElement (pctxt, "ip", -1);
+
+   stat = asn1PD_H225TransportAddress_ipAddress_ip (pctxt, &pvalue->ip);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "ip", -1);
+
+   /* decode port */
+
+   invokeStartElement (pctxt, "port", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->port);
+
+   invokeEndElement (pctxt, "port", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_ip                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_route_element              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportAddress_ipSourceRoute_route_element    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, H225TransportAddress_ipSourceRoute_route_element);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_routing                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* strict */
+         case 0:
+            invokeStartElement (pctxt, "strict", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "strict", -1);
+
+            break;
+
+         /* loose */
+         case 1:
+            invokeStartElement (pctxt, "loose", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "loose", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode ip */
+
+   invokeStartElement (pctxt, "ip", -1);
+
+   stat = asn1PD_H225TransportAddress_ipSourceRoute_ip (pctxt, &pvalue->ip);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "ip", -1);
+
+   /* decode port */
+
+   invokeStartElement (pctxt, "port", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->port);
+
+   invokeEndElement (pctxt, "port", -1);
+
+   /* decode route */
+
+   invokeStartElement (pctxt, "route", -1);
+
+   stat = asn1PD_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->route);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "route", -1);
+
+   /* decode routing */
+
+   invokeStartElement (pctxt, "routing", -1);
+
+   stat = asn1PD_H225TransportAddress_ipSourceRoute_routing (pctxt, &pvalue->routing);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "routing", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_node                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_netnum                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_port                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode node */
+
+   invokeStartElement (pctxt, "node", -1);
+
+   stat = asn1PD_H225TransportAddress_ipxAddress_node (pctxt, &pvalue->node);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "node", -1);
+
+   /* decode netnum */
+
+   invokeStartElement (pctxt, "netnum", -1);
+
+   stat = asn1PD_H225TransportAddress_ipxAddress_netnum (pctxt, &pvalue->netnum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "netnum", -1);
+
+   /* decode port */
+
+   invokeStartElement (pctxt, "port", -1);
+
+   stat = asn1PD_H225TransportAddress_ipxAddress_port (pctxt, &pvalue->port);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "port", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ip6Address_ip                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ip6Address                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode ip */
+
+   invokeStartElement (pctxt, "ip", -1);
+
+   stat = asn1PD_H225TransportAddress_ip6Address_ip (pctxt, &pvalue->ip);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "ip", -1);
+
+   /* decode port */
+
+   invokeStartElement (pctxt, "port", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->port);
+
+   invokeEndElement (pctxt, "port", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_netBios                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_nsap                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H221NonStandard                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode t35CountryCode */
+
+   invokeStartElement (pctxt, "t35CountryCode", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->t35CountryCode, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->t35CountryCode);
+
+   invokeEndElement (pctxt, "t35CountryCode", -1);
+
+   /* decode t35Extension */
+
+   invokeStartElement (pctxt, "t35Extension", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->t35Extension, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->t35Extension);
+
+   invokeEndElement (pctxt, "t35Extension", -1);
+
+   /* decode manufacturerCode */
+
+   invokeStartElement (pctxt, "manufacturerCode", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->manufacturerCode, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->manufacturerCode);
+
+   invokeEndElement (pctxt, "manufacturerCode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* object */
+         case 0:
+            invokeStartElement (pctxt, "object", -1);
+
+            pvalue->u.object = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.object);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.object->numids, pvalue->u.object->subid);
+
+            invokeEndElement (pctxt, "object", -1);
+
+            break;
+
+         /* h221NonStandard */
+         case 1:
+            invokeStartElement (pctxt, "h221NonStandard", -1);
+
+            pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H225H221NonStandard);
+
+            stat = asn1PD_H225H221NonStandard (pctxt, pvalue->u.h221NonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h221NonStandard", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode nonStandardIdentifier */
+
+   invokeStartElement (pctxt, "nonStandardIdentifier", -1);
+
+   stat = asn1PD_H225NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nonStandardIdentifier", -1);
+
+   /* decode data */
+
+   invokeStartElement (pctxt, "data", -1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->data);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->data.numocts, pvalue->data.data);
+
+   invokeEndElement (pctxt, "data", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* ipAddress */
+         case 0:
+            invokeStartElement (pctxt, "ipAddress", -1);
+
+            pvalue->u.ipAddress = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipAddress);
+
+            stat = asn1PD_H225TransportAddress_ipAddress (pctxt, pvalue->u.ipAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "ipAddress", -1);
+
+            break;
+
+         /* ipSourceRoute */
+         case 1:
+            invokeStartElement (pctxt, "ipSourceRoute", -1);
+
+            pvalue->u.ipSourceRoute = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipSourceRoute);
+
+            stat = asn1PD_H225TransportAddress_ipSourceRoute (pctxt, pvalue->u.ipSourceRoute);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "ipSourceRoute", -1);
+
+            break;
+
+         /* ipxAddress */
+         case 2:
+            invokeStartElement (pctxt, "ipxAddress", -1);
+
+            pvalue->u.ipxAddress = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipxAddress);
+
+            stat = asn1PD_H225TransportAddress_ipxAddress (pctxt, pvalue->u.ipxAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "ipxAddress", -1);
+
+            break;
+
+         /* ip6Address */
+         case 3:
+            invokeStartElement (pctxt, "ip6Address", -1);
+
+            pvalue->u.ip6Address = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ip6Address);
+
+            stat = asn1PD_H225TransportAddress_ip6Address (pctxt, pvalue->u.ip6Address);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "ip6Address", -1);
+
+            break;
+
+         /* netBios */
+         case 4:
+            invokeStartElement (pctxt, "netBios", -1);
+
+            pvalue->u.netBios = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_netBios);
+
+            stat = asn1PD_H225TransportAddress_netBios (pctxt, pvalue->u.netBios);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "netBios", -1);
+
+            break;
+
+         /* nsap */
+         case 5:
+            invokeStartElement (pctxt, "nsap", -1);
+
+            pvalue->u.nsap = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_nsap);
+
+            stat = asn1PD_H225TransportAddress_nsap (pctxt, pvalue->u.nsap);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nsap", -1);
+
+            break;
+
+         /* nonStandardAddress */
+         case 6:
+            invokeStartElement (pctxt, "nonStandardAddress", -1);
+
+            pvalue->u.nonStandardAddress = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
+
+            stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandardAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandardAddress", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 8;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PublicTypeOfNumber                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unknown */
+         case 0:
+            invokeStartElement (pctxt, "unknown", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unknown", -1);
+
+            break;
+
+         /* internationalNumber */
+         case 1:
+            invokeStartElement (pctxt, "internationalNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "internationalNumber", -1);
+
+            break;
+
+         /* nationalNumber */
+         case 2:
+            invokeStartElement (pctxt, "nationalNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nationalNumber", -1);
+
+            break;
+
+         /* networkSpecificNumber */
+         case 3:
+            invokeStartElement (pctxt, "networkSpecificNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "networkSpecificNumber", -1);
+
+            break;
+
+         /* subscriberNumber */
+         case 4:
+            invokeStartElement (pctxt, "subscriberNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "subscriberNumber", -1);
+
+            break;
+
+         /* abbreviatedNumber */
+         case 5:
+            invokeStartElement (pctxt, "abbreviatedNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "abbreviatedNumber", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PublicPartyNumber                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode publicTypeOfNumber */
+
+   invokeStartElement (pctxt, "publicTypeOfNumber", -1);
+
+   stat = asn1PD_H225PublicTypeOfNumber (pctxt, &pvalue->publicTypeOfNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "publicTypeOfNumber", -1);
+
+   /* decode publicNumberDigits */
+
+   invokeStartElement (pctxt, "publicNumberDigits", -1);
+
+   stat = asn1PD_H225NumberDigits (pctxt, &pvalue->publicNumberDigits);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "publicNumberDigits", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PrivateTypeOfNumber                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unknown */
+         case 0:
+            invokeStartElement (pctxt, "unknown", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unknown", -1);
+
+            break;
+
+         /* level2RegionalNumber */
+         case 1:
+            invokeStartElement (pctxt, "level2RegionalNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "level2RegionalNumber", -1);
+
+            break;
+
+         /* level1RegionalNumber */
+         case 2:
+            invokeStartElement (pctxt, "level1RegionalNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "level1RegionalNumber", -1);
+
+            break;
+
+         /* pISNSpecificNumber */
+         case 3:
+            invokeStartElement (pctxt, "pISNSpecificNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "pISNSpecificNumber", -1);
+
+            break;
+
+         /* localNumber */
+         case 4:
+            invokeStartElement (pctxt, "localNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "localNumber", -1);
+
+            break;
+
+         /* abbreviatedNumber */
+         case 5:
+            invokeStartElement (pctxt, "abbreviatedNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "abbreviatedNumber", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PrivatePartyNumber                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode privateTypeOfNumber */
+
+   invokeStartElement (pctxt, "privateTypeOfNumber", -1);
+
+   stat = asn1PD_H225PrivateTypeOfNumber (pctxt, &pvalue->privateTypeOfNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "privateTypeOfNumber", -1);
+
+   /* decode privateNumberDigits */
+
+   invokeStartElement (pctxt, "privateNumberDigits", -1);
+
+   stat = asn1PD_H225NumberDigits (pctxt, &pvalue->privateNumberDigits);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "privateNumberDigits", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PartyNumber                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* e164Number */
+         case 0:
+            invokeStartElement (pctxt, "e164Number", -1);
+
+            pvalue->u.e164Number = ALLOC_ASN1ELEM (pctxt, H225PublicPartyNumber);
+
+            stat = asn1PD_H225PublicPartyNumber (pctxt, pvalue->u.e164Number);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "e164Number", -1);
+
+            break;
+
+         /* dataPartyNumber */
+         case 1:
+            invokeStartElement (pctxt, "dataPartyNumber", -1);
+
+            stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.dataPartyNumber);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "dataPartyNumber", -1);
+
+            break;
+
+         /* telexPartyNumber */
+         case 2:
+            invokeStartElement (pctxt, "telexPartyNumber", -1);
+
+            stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.telexPartyNumber);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "telexPartyNumber", -1);
+
+            break;
+
+         /* privateNumber */
+         case 3:
+            invokeStartElement (pctxt, "privateNumber", -1);
+
+            pvalue->u.privateNumber = ALLOC_ASN1ELEM (pctxt, H225PrivatePartyNumber);
+
+            stat = asn1PD_H225PrivatePartyNumber (pctxt, pvalue->u.privateNumber);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "privateNumber", -1);
+
+            break;
+
+         /* nationalStandardPartyNumber */
+         case 4:
+            invokeStartElement (pctxt, "nationalStandardPartyNumber", -1);
+
+            stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.nationalStandardPartyNumber);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nationalStandardPartyNumber", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_system_id                                     */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet;
+
+EXTERN int asn1PD_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue)
+{
+   static Asn1SizeCnst sid_lsize1 = { 0, 1, 4, 0 };
+   static Asn1SizeCnst mid_lsize1 = { 0, 1, 4, 0 };
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* sid */
+         case 0:
+            invokeStartElement (pctxt, "sid", -1);
+
+            addSizeConstraint (pctxt, &sid_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.sid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet, 4, 4, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.sid);
+
+            invokeEndElement (pctxt, "sid", -1);
+
+            break;
+
+         /* mid */
+         case 1:
+            invokeStartElement (pctxt, "mid", -1);
+
+            addSizeConstraint (pctxt, &mid_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.mid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet, 4, 4, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.mid);
+
+            invokeEndElement (pctxt, "mid", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_systemMyTypeCode                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_systemAccessType                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_qualificationInformationCode                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM                                               */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet;
+
+EXTERN int asn1PD_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue)
+{
+   static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst min_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst mdn_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst esn_lsize1 = { 0, 16, 16, 0 };
+   static Asn1SizeCnst mscid_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst sesn_lsize1 = { 0, 16, 16, 0 };
+   static Asn1SizeCnst soc_lsize1 = { 0, 3, 16, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.imsiPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.minPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mdnPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.msisdnPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.esnPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mscidPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.systemMyTypeCodePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.systemAccessTypePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.qualificationInformationCodePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sesnPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.socPresent = optbit;
+
+   /* decode imsi */
+
+   if (pvalue->m.imsiPresent) {
+      invokeStartElement (pctxt, "imsi", -1);
+
+      addSizeConstraint (pctxt, &imsi_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->imsi, gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->imsi);
+
+      invokeEndElement (pctxt, "imsi", -1);
+   }
+
+   /* decode min */
+
+   if (pvalue->m.minPresent) {
+      invokeStartElement (pctxt, "min", -1);
+
+      addSizeConstraint (pctxt, &min_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->min, gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->min);
+
+      invokeEndElement (pctxt, "min", -1);
+   }
+
+   /* decode mdn */
+
+   if (pvalue->m.mdnPresent) {
+      invokeStartElement (pctxt, "mdn", -1);
+
+      addSizeConstraint (pctxt, &mdn_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->mdn, gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->mdn);
+
+      invokeEndElement (pctxt, "mdn", -1);
+   }
+
+   /* decode msisdn */
+
+   if (pvalue->m.msisdnPresent) {
+      invokeStartElement (pctxt, "msisdn", -1);
+
+      addSizeConstraint (pctxt, &msisdn_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->msisdn, gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->msisdn);
+
+      invokeEndElement (pctxt, "msisdn", -1);
+   }
+
+   /* decode esn */
+
+   if (pvalue->m.esnPresent) {
+      invokeStartElement (pctxt, "esn", -1);
+
+      addSizeConstraint (pctxt, &esn_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->esn, gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->esn);
+
+      invokeEndElement (pctxt, "esn", -1);
+   }
+
+   /* decode mscid */
+
+   if (pvalue->m.mscidPresent) {
+      invokeStartElement (pctxt, "mscid", -1);
+
+      addSizeConstraint (pctxt, &mscid_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->mscid, gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->mscid);
+
+      invokeEndElement (pctxt, "mscid", -1);
+   }
+
+   /* decode system_id */
+
+   invokeStartElement (pctxt, "system_id", -1);
+
+   stat = asn1PD_H225ANSI_41_UIM_system_id (pctxt, &pvalue->system_id);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "system_id", -1);
+
+   /* decode systemMyTypeCode */
+
+   if (pvalue->m.systemMyTypeCodePresent) {
+      invokeStartElement (pctxt, "systemMyTypeCode", -1);
+
+      stat = asn1PD_H225ANSI_41_UIM_systemMyTypeCode (pctxt, &pvalue->systemMyTypeCode);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "systemMyTypeCode", -1);
+   }
+
+   /* decode systemAccessType */
+
+   if (pvalue->m.systemAccessTypePresent) {
+      invokeStartElement (pctxt, "systemAccessType", -1);
+
+      stat = asn1PD_H225ANSI_41_UIM_systemAccessType (pctxt, &pvalue->systemAccessType);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "systemAccessType", -1);
+   }
+
+   /* decode qualificationInformationCode */
+
+   if (pvalue->m.qualificationInformationCodePresent) {
+      invokeStartElement (pctxt, "qualificationInformationCode", -1);
+
+      stat = asn1PD_H225ANSI_41_UIM_qualificationInformationCode (pctxt, &pvalue->qualificationInformationCode);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "qualificationInformationCode", -1);
+   }
+
+   /* decode sesn */
+
+   if (pvalue->m.sesnPresent) {
+      invokeStartElement (pctxt, "sesn", -1);
+
+      addSizeConstraint (pctxt, &sesn_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->sesn, gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->sesn);
+
+      invokeEndElement (pctxt, "sesn", -1);
+   }
+
+   /* decode soc */
+
+   if (pvalue->m.socPresent) {
+      invokeStartElement (pctxt, "soc", -1);
+
+      addSizeConstraint (pctxt, &soc_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->soc, gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->soc);
+
+      invokeEndElement (pctxt, "soc", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GSM_UIM_tmsi                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GSM_UIM                                                   */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imsi_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imei_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet;
+
+EXTERN int asn1PD_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue)
+{
+   static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst imei_lsize1 = { 0, 15, 16, 0 };
+   static Asn1SizeCnst hplmn_lsize1 = { 0, 1, 4, 0 };
+   static Asn1SizeCnst vplmn_lsize1 = { 0, 1, 4, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.imsiPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tmsiPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.msisdnPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.imeiPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.hplmnPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.vplmnPresent = optbit;
+
+   /* decode imsi */
+
+   if (pvalue->m.imsiPresent) {
+      invokeStartElement (pctxt, "imsi", -1);
+
+      addSizeConstraint (pctxt, &imsi_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->imsi, gs_H323_MESSAGES_GSM_UIM_imsi_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->imsi);
+
+      invokeEndElement (pctxt, "imsi", -1);
+   }
+
+   /* decode tmsi */
+
+   if (pvalue->m.tmsiPresent) {
+      invokeStartElement (pctxt, "tmsi", -1);
+
+      stat = asn1PD_H225GSM_UIM_tmsi (pctxt, &pvalue->tmsi);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tmsi", -1);
+   }
+
+   /* decode msisdn */
+
+   if (pvalue->m.msisdnPresent) {
+      invokeStartElement (pctxt, "msisdn", -1);
+
+      addSizeConstraint (pctxt, &msisdn_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->msisdn, gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->msisdn);
+
+      invokeEndElement (pctxt, "msisdn", -1);
+   }
+
+   /* decode imei */
+
+   if (pvalue->m.imeiPresent) {
+      invokeStartElement (pctxt, "imei", -1);
+
+      addSizeConstraint (pctxt, &imei_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->imei, gs_H323_MESSAGES_GSM_UIM_imei_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->imei);
+
+      invokeEndElement (pctxt, "imei", -1);
+   }
+
+   /* decode hplmn */
+
+   if (pvalue->m.hplmnPresent) {
+      invokeStartElement (pctxt, "hplmn", -1);
+
+      addSizeConstraint (pctxt, &hplmn_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->hplmn, gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->hplmn);
+
+      invokeEndElement (pctxt, "hplmn", -1);
+   }
+
+   /* decode vplmn */
+
+   if (pvalue->m.vplmnPresent) {
+      invokeStartElement (pctxt, "vplmn", -1);
+
+      addSizeConstraint (pctxt, &vplmn_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->vplmn, gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->vplmn);
+
+      invokeEndElement (pctxt, "vplmn", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MobileUIM                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* ansi_41_uim */
+         case 0:
+            invokeStartElement (pctxt, "ansi_41_uim", -1);
+
+            pvalue->u.ansi_41_uim = ALLOC_ASN1ELEM (pctxt, H225ANSI_41_UIM);
+
+            stat = asn1PD_H225ANSI_41_UIM (pctxt, pvalue->u.ansi_41_uim);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "ansi_41_uim", -1);
+
+            break;
+
+         /* gsm_uim */
+         case 1:
+            invokeStartElement (pctxt, "gsm_uim", -1);
+
+            pvalue->u.gsm_uim = ALLOC_ASN1ELEM (pctxt, H225GSM_UIM);
+
+            stat = asn1PD_H225GSM_UIM (pctxt, pvalue->u.gsm_uim);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gsm_uim", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AliasAddress                                              */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet;
+
+EXTERN int asn1PD_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue)
+{
+   static Asn1SizeCnst dialedDigits_lsize1 = { 0, 1, 128, 0 };
+   static Asn1SizeCnst h323_ID_lsize1 = { 0, 1, 256, 0 };
+   static Asn1SizeCnst url_ID_lsize1 = { 0, 1, 512, 0 };
+   static Asn1SizeCnst email_ID_lsize1 = { 0, 1, 512, 0 };
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* dialedDigits */
+         case 0:
+            invokeStartElement (pctxt, "dialedDigits", -1);
+
+            addSizeConstraint (pctxt, &dialedDigits_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.dialedDigits, gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet, 4, 4, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.dialedDigits);
+
+            invokeEndElement (pctxt, "dialedDigits", -1);
+
+            break;
+
+         /* h323_ID */
+         case 1:
+            invokeStartElement (pctxt, "h323_ID", -1);
+
+            addSizeConstraint (pctxt, &h323_ID_lsize1);
+
+            stat = decodeBMPString (pctxt, &pvalue->u.h323_ID, 0);
+            if (stat != ASN_OK) return stat;
+            invokeCharStr16BitValue (pctxt, pvalue->u.h323_ID.nchars, pvalue->u.h323_ID.data);
+
+            invokeEndElement (pctxt, "h323_ID", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* url_ID */
+         case 3:
+            invokeStartElement (pctxt, "url_ID", -1);
+
+            addSizeConstraint (pctxt, &url_ID_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.url_ID, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.url_ID);
+
+            invokeEndElement (pctxt, "url_ID", -1);
+
+            break;
+
+         /* transportID */
+         case 4:
+            invokeStartElement (pctxt, "transportID", -1);
+
+            pvalue->u.transportID = ALLOC_ASN1ELEM (pctxt, H225TransportAddress);
+
+            stat = asn1PD_H225TransportAddress (pctxt, pvalue->u.transportID);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transportID", -1);
+
+            break;
+
+         /* email_ID */
+         case 5:
+            invokeStartElement (pctxt, "email_ID", -1);
+
+            addSizeConstraint (pctxt, &email_ID_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.email_ID, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.email_ID);
+
+            invokeEndElement (pctxt, "email_ID", -1);
+
+            break;
+
+         /* partyNumber */
+         case 6:
+            invokeStartElement (pctxt, "partyNumber", -1);
+
+            pvalue->u.partyNumber = ALLOC_ASN1ELEM (pctxt, H225PartyNumber);
+
+            stat = asn1PD_H225PartyNumber (pctxt, pvalue->u.partyNumber);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "partyNumber", -1);
+
+            break;
+
+         /* mobileUIM */
+         case 7:
+            invokeStartElement (pctxt, "mobileUIM", -1);
+
+            pvalue->u.mobileUIM = ALLOC_ASN1ELEM (pctxt, H225MobileUIM);
+
+            stat = asn1PD_H225MobileUIM (pctxt, pvalue->u.mobileUIM);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "mobileUIM", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Content_compound                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
+   int stat = ASN_OK;
+   H225EnumeratedParameter* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225EnumeratedParameter);
+
+      stat = asn1PD_H225EnumeratedParameter (pctxt, (H225EnumeratedParameter*)pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Content_nested                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   H225GenericData* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225GenericData);
+
+      stat = asn1PD_H225GenericData (pctxt, (H225GenericData*)pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Content                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Content (OOCTXT* pctxt, H225Content* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 11);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* raw */
+         case 0:
+            invokeStartElement (pctxt, "raw", -1);
+
+            pvalue->u.raw = ALLOC_ASN1ELEM (pctxt, ASN1DynOctStr);
+
+            stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue->u.raw);
+            if (stat != ASN_OK) return stat;
+            invokeOctStrValue (pctxt, pvalue->u.raw->numocts, pvalue->u.raw->data);
+
+            invokeEndElement (pctxt, "raw", -1);
+
+            break;
+
+         /* text */
+         case 1:
+            invokeStartElement (pctxt, "text", -1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.text, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.text);
+
+            invokeEndElement (pctxt, "text", -1);
+
+            break;
+
+         /* unicode */
+         case 2:
+            invokeStartElement (pctxt, "unicode", -1);
+
+            stat = decodeBMPString (pctxt, &pvalue->u.unicode, 0);
+            if (stat != ASN_OK) return stat;
+            invokeCharStr16BitValue (pctxt, pvalue->u.unicode.nchars, pvalue->u.unicode.data);
+
+            invokeEndElement (pctxt, "unicode", -1);
+
+            break;
+
+         /* bool_ */
+         case 3:
+            invokeStartElement (pctxt, "bool_", -1);
+
+            stat = DECODEBIT (pctxt, &pvalue->u.bool_);
+            if (stat != ASN_OK) return stat;
+            invokeBoolValue (pctxt, pvalue->u.bool_);
+
+            invokeEndElement (pctxt, "bool_", -1);
+
+            break;
+
+         /* number8 */
+         case 4:
+            invokeStartElement (pctxt, "number8", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.number8, 0U, 255U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.number8);
+
+            invokeEndElement (pctxt, "number8", -1);
+
+            break;
+
+         /* number16 */
+         case 5:
+            invokeStartElement (pctxt, "number16", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.number16, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.number16);
+
+            invokeEndElement (pctxt, "number16", -1);
+
+            break;
+
+         /* number32 */
+         case 6:
+            invokeStartElement (pctxt, "number32", -1);
+
+            stat = decodeConsUnsigned (pctxt, &pvalue->u.number32, 0U, ASN1UINT_MAX);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.number32);
+
+            invokeEndElement (pctxt, "number32", -1);
+
+            break;
+
+         /* id */
+         case 7:
+            invokeStartElement (pctxt, "id", -1);
+
+            pvalue->u.id = ALLOC_ASN1ELEM (pctxt, H225GenericIdentifier);
+
+            stat = asn1PD_H225GenericIdentifier (pctxt, pvalue->u.id);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "id", -1);
+
+            break;
+
+         /* alias */
+         case 8:
+            invokeStartElement (pctxt, "alias", -1);
+
+            pvalue->u.alias = ALLOC_ASN1ELEM (pctxt, H225AliasAddress);
+
+            stat = asn1PD_H225AliasAddress (pctxt, pvalue->u.alias);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "alias", -1);
+
+            break;
+
+         /* transport */
+         case 9:
+            invokeStartElement (pctxt, "transport", -1);
+
+            pvalue->u.transport = ALLOC_ASN1ELEM (pctxt, H225TransportAddress);
+
+            stat = asn1PD_H225TransportAddress (pctxt, pvalue->u.transport);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transport", -1);
+
+            break;
+
+         /* compound */
+         case 10:
+            invokeStartElement (pctxt, "compound", -1);
+
+            pvalue->u.compound = ALLOC_ASN1ELEM (pctxt, H225Content_compound);
+
+            stat = asn1PD_H225Content_compound (pctxt, pvalue->u.compound);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "compound", -1);
+
+            break;
+
+         /* nested */
+         case 11:
+            invokeStartElement (pctxt, "nested", -1);
+
+            pvalue->u.nested = ALLOC_ASN1ELEM (pctxt, H225Content_nested);
+
+            stat = asn1PD_H225Content_nested (pctxt, pvalue->u.nested);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nested", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 13;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnumeratedParameter                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.contentPresent = optbit;
+
+   /* decode id */
+
+   invokeStartElement (pctxt, "id", -1);
+
+   stat = asn1PD_H225GenericIdentifier (pctxt, &pvalue->id);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "id", -1);
+
+   /* decode content */
+
+   if (pvalue->m.contentPresent) {
+      invokeStartElement (pctxt, "content", -1);
+
+      stat = asn1PD_H225Content (pctxt, &pvalue->content);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "content", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericData_parameters                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
+   int stat = ASN_OK;
+   H225EnumeratedParameter* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225EnumeratedParameter);
+
+      stat = asn1PD_H225EnumeratedParameter (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericData                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.parametersPresent = optbit;
+
+   /* decode id */
+
+   invokeStartElement (pctxt, "id", -1);
+
+   stat = asn1PD_H225GenericIdentifier (pctxt, &pvalue->id);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "id", -1);
+
+   /* decode parameters */
+
+   if (pvalue->m.parametersPresent) {
+      invokeStartElement (pctxt, "parameters", -1);
+
+      stat = asn1PD_H225GenericData_parameters (pctxt, &pvalue->parameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "parameters", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FeatureDescriptor                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = asn1PD_H225GenericData (pctxt, pvalue);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FastStartToken                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = asn1PD_H235ClearToken (pctxt, pvalue);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedFastStartToken                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeOpenType (pctxt, &pvalue->data, &pvalue->numocts);
+   if (stat != ASN_OK) return stat;
+   invokeOpenTypeValue
+      (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation_user_data_user_information           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 131, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointType_set                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 32, 32, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier_productId                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier_versionId                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo_cic_element                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo_pointCode                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 5, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CarrierInfo_carrierIdentificationCode                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 3, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallTerminationCause_releaseCompleteCauseIE               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 32, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AliasAddress                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue)
+{
+   int stat = ASN_OK;
+   H225AliasAddress* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AliasAddress);
+
+         stat = asn1PD_H225AliasAddress (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.productIdPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.versionIdPresent = optbit;
+
+   /* decode vendor */
+
+   invokeStartElement (pctxt, "vendor", -1);
+
+   stat = asn1PD_H225H221NonStandard (pctxt, &pvalue->vendor);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "vendor", -1);
+
+   /* decode productId */
+
+   if (pvalue->m.productIdPresent) {
+      invokeStartElement (pctxt, "productId", -1);
+
+      stat = asn1PD_H225VendorIdentifier_productId (pctxt, &pvalue->productId);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "productId", -1);
+   }
+
+   /* decode versionId */
+
+   if (pvalue->m.versionIdPresent) {
+      invokeStartElement (pctxt, "versionId", -1);
+
+      stat = asn1PD_H225VendorIdentifier_versionId (pctxt, &pvalue->versionId);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "versionId", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.enterpriseNumberPresent = 1;
+
+                     invokeStartElement (pctxt, "enterpriseNumber", -1);
+
+                     stat = decodeObjectIdentifier (pctxt, &pvalue->enterpriseNumber);
+                     if (stat != ASN_OK) return stat;
+                     invokeOidValue (pctxt, pvalue->enterpriseNumber.numids, pvalue->enterpriseNumber.subid);
+
+                     invokeEndElement (pctxt, "enterpriseNumber", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperInfo                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataRate                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.channelMultiplierPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode channelRate */
+
+   invokeStartElement (pctxt, "channelRate", -1);
+
+   stat = asn1PD_H225BandWidth (pctxt, &pvalue->channelRate);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "channelRate", -1);
+
+   /* decode channelMultiplier */
+
+   if (pvalue->m.channelMultiplierPresent) {
+      invokeStartElement (pctxt, "channelMultiplier", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->channelMultiplier, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->channelMultiplier);
+
+      invokeEndElement (pctxt, "channelMultiplier", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225DataRate                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue)
+{
+   int stat = ASN_OK;
+   H225DataRate* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225DataRate);
+
+         stat = asn1PD_H225DataRate (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SupportedPrefix                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode prefix */
+
+   invokeStartElement (pctxt, "prefix", -1);
+
+   stat = asn1PD_H225AliasAddress (pctxt, &pvalue->prefix);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "prefix", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225SupportedPrefix                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue)
+{
+   int stat = ASN_OK;
+   H225SupportedPrefix* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225SupportedPrefix);
+
+         stat = asn1PD_H225SupportedPrefix (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H310Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.dataRatesSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+                     stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "dataRatesSupported", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H320Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.dataRatesSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+                     stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "dataRatesSupported", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H321Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.dataRatesSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+                     stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "dataRatesSupported", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H322Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.dataRatesSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+                     stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "dataRatesSupported", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.dataRatesSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+                     stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "dataRatesSupported", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H324Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.dataRatesSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+                     stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "dataRatesSupported", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VoiceCaps                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.dataRatesSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+                     stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "dataRatesSupported", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T120OnlyCaps                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.dataRatesSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+                     stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "dataRatesSupported", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardProtocol                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.dataRatesSupportedPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode dataRatesSupported */
+
+   if (pvalue->m.dataRatesSupportedPresent) {
+      invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+      stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "dataRatesSupported", -1);
+   }
+
+   /* decode supportedPrefixes */
+
+   invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+   stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "supportedPrefixes", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxAnnexbOnlyCaps                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.dataRatesSupportedPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode dataRatesSupported */
+
+   if (pvalue->m.dataRatesSupportedPresent) {
+      invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+      stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "dataRatesSupported", -1);
+   }
+
+   /* decode supportedPrefixes */
+
+   invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+   stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "supportedPrefixes", -1);
+
+   /* decode t38FaxProtocol */
+
+   invokeStartElement (pctxt, "t38FaxProtocol", -1);
+
+   stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t38FaxProtocol", -1);
+
+   /* decode t38FaxProfile */
+
+   invokeStartElement (pctxt, "t38FaxProfile", -1);
+
+   stat = asn1PD_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t38FaxProfile", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SIPCaps                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.dataRatesSupportedPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.supportedPrefixesPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode dataRatesSupported */
+
+   if (pvalue->m.dataRatesSupportedPresent) {
+      invokeStartElement (pctxt, "dataRatesSupported", -1);
+
+      stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "dataRatesSupported", -1);
+   }
+
+   /* decode supportedPrefixes */
+
+   if (pvalue->m.supportedPrefixesPresent) {
+      invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+      stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "supportedPrefixes", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SupportedProtocols                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 8);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandardData */
+         case 0:
+            invokeStartElement (pctxt, "nonStandardData", -1);
+
+            pvalue->u.nonStandardData = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
+
+            stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandardData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandardData", -1);
+
+            break;
+
+         /* h310 */
+         case 1:
+            invokeStartElement (pctxt, "h310", -1);
+
+            pvalue->u.h310 = ALLOC_ASN1ELEM (pctxt, H225H310Caps);
+
+            stat = asn1PD_H225H310Caps (pctxt, pvalue->u.h310);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h310", -1);
+
+            break;
+
+         /* h320 */
+         case 2:
+            invokeStartElement (pctxt, "h320", -1);
+
+            pvalue->u.h320 = ALLOC_ASN1ELEM (pctxt, H225H320Caps);
+
+            stat = asn1PD_H225H320Caps (pctxt, pvalue->u.h320);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h320", -1);
+
+            break;
+
+         /* h321 */
+         case 3:
+            invokeStartElement (pctxt, "h321", -1);
+
+            pvalue->u.h321 = ALLOC_ASN1ELEM (pctxt, H225H321Caps);
+
+            stat = asn1PD_H225H321Caps (pctxt, pvalue->u.h321);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h321", -1);
+
+            break;
+
+         /* h322 */
+         case 4:
+            invokeStartElement (pctxt, "h322", -1);
+
+            pvalue->u.h322 = ALLOC_ASN1ELEM (pctxt, H225H322Caps);
+
+            stat = asn1PD_H225H322Caps (pctxt, pvalue->u.h322);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h322", -1);
+
+            break;
+
+         /* h323 */
+         case 5:
+            invokeStartElement (pctxt, "h323", -1);
+
+            pvalue->u.h323 = ALLOC_ASN1ELEM (pctxt, H225H323Caps);
+
+            stat = asn1PD_H225H323Caps (pctxt, pvalue->u.h323);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h323", -1);
+
+            break;
+
+         /* h324 */
+         case 6:
+            invokeStartElement (pctxt, "h324", -1);
+
+            pvalue->u.h324 = ALLOC_ASN1ELEM (pctxt, H225H324Caps);
+
+            stat = asn1PD_H225H324Caps (pctxt, pvalue->u.h324);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h324", -1);
+
+            break;
+
+         /* voice */
+         case 7:
+            invokeStartElement (pctxt, "voice", -1);
+
+            pvalue->u.voice = ALLOC_ASN1ELEM (pctxt, H225VoiceCaps);
+
+            stat = asn1PD_H225VoiceCaps (pctxt, pvalue->u.voice);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "voice", -1);
+
+            break;
+
+         /* t120_only */
+         case 8:
+            invokeStartElement (pctxt, "t120_only", -1);
+
+            pvalue->u.t120_only = ALLOC_ASN1ELEM (pctxt, H225T120OnlyCaps);
+
+            stat = asn1PD_H225T120OnlyCaps (pctxt, pvalue->u.t120_only);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t120_only", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 10;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* nonStandardProtocol */
+         case 10:
+            invokeStartElement (pctxt, "nonStandardProtocol", -1);
+
+            pvalue->u.nonStandardProtocol = ALLOC_ASN1ELEM (pctxt, H225NonStandardProtocol);
+
+            stat = asn1PD_H225NonStandardProtocol (pctxt, pvalue->u.nonStandardProtocol);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandardProtocol", -1);
+
+            break;
+
+         /* t38FaxAnnexbOnly */
+         case 11:
+            invokeStartElement (pctxt, "t38FaxAnnexbOnly", -1);
+
+            pvalue->u.t38FaxAnnexbOnly = ALLOC_ASN1ELEM (pctxt, H225T38FaxAnnexbOnlyCaps);
+
+            stat = asn1PD_H225T38FaxAnnexbOnlyCaps (pctxt, pvalue->u.t38FaxAnnexbOnly);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t38FaxAnnexbOnly", -1);
+
+            break;
+
+         /* sip */
+         case 12:
+            invokeStartElement (pctxt, "sip", -1);
+
+            pvalue->u.sip = ALLOC_ASN1ELEM (pctxt, H225SIPCaps);
+
+            stat = asn1PD_H225SIPCaps (pctxt, pvalue->u.sip);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "sip", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225SupportedProtocols                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue)
+{
+   int stat = ASN_OK;
+   H225SupportedProtocols* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225SupportedProtocols);
+
+         stat = asn1PD_H225SupportedProtocols (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatewayInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.protocolPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode protocol */
+
+   if (pvalue->m.protocolPresent) {
+      invokeStartElement (pctxt, "protocol", -1);
+
+      stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocol);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "protocol", -1);
+   }
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  McuInfo                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.protocolPresent = 1;
+
+                     invokeStartElement (pctxt, "protocol", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocol);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "protocol", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalInfo                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocolAlternateIdentifier                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TunnelledProtocolAlternateIdentifier (OOCTXT* pctxt, H225TunnelledProtocolAlternateIdentifier* pvalue)
+{
+   static Asn1SizeCnst protocolType_lsize1 = { 0, 1, 64, 0 };
+   static Asn1SizeCnst protocolVariant_lsize1 = { 0, 1, 64, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.protocolVariantPresent = optbit;
+
+   /* decode protocolType */
+
+   invokeStartElement (pctxt, "protocolType", -1);
+
+   addSizeConstraint (pctxt, &protocolType_lsize1);
+
+   stat = decodeConstrainedStringEx (pctxt, &pvalue->protocolType, 0, 8, 7, 7);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, pvalue->protocolType);
+
+   invokeEndElement (pctxt, "protocolType", -1);
+
+   /* decode protocolVariant */
+
+   if (pvalue->m.protocolVariantPresent) {
+      invokeStartElement (pctxt, "protocolVariant", -1);
+
+      addSizeConstraint (pctxt, &protocolVariant_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->protocolVariant, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->protocolVariant);
+
+      invokeEndElement (pctxt, "protocolVariant", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocol_id                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* tunnelledProtocolObjectID */
+         case 0:
+            invokeStartElement (pctxt, "tunnelledProtocolObjectID", -1);
+
+            pvalue->u.tunnelledProtocolObjectID = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.tunnelledProtocolObjectID);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.tunnelledProtocolObjectID->numids, pvalue->u.tunnelledProtocolObjectID->subid);
+
+            invokeEndElement (pctxt, "tunnelledProtocolObjectID", -1);
+
+            break;
+
+         /* tunnelledProtocolAlternateID */
+         case 1:
+            invokeStartElement (pctxt, "tunnelledProtocolAlternateID", -1);
+
+            pvalue->u.tunnelledProtocolAlternateID = ALLOC_ASN1ELEM (pctxt, H225TunnelledProtocolAlternateIdentifier);
+
+            stat = asn1PD_H225TunnelledProtocolAlternateIdentifier (pctxt, pvalue->u.tunnelledProtocolAlternateID);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "tunnelledProtocolAlternateID", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocol                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TunnelledProtocol (OOCTXT* pctxt, H225TunnelledProtocol* pvalue)
+{
+   static Asn1SizeCnst subIdentifier_lsize1 = { 0, 1, 64, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.subIdentifierPresent = optbit;
+
+   /* decode id */
+
+   invokeStartElement (pctxt, "id", -1);
+
+   stat = asn1PD_H225TunnelledProtocol_id (pctxt, &pvalue->id);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "id", -1);
+
+   /* decode subIdentifier */
+
+   if (pvalue->m.subIdentifierPresent) {
+      invokeStartElement (pctxt, "subIdentifier", -1);
+
+      addSizeConstraint (pctxt, &subIdentifier_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->subIdentifier, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->subIdentifier);
+
+      invokeEndElement (pctxt, "subIdentifier", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TunnelledProtocol                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225TunnelledProtocol (OOCTXT* pctxt, H225_SeqOfH225TunnelledProtocol* pvalue)
+{
+   int stat = ASN_OK;
+   H225TunnelledProtocol* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225TunnelledProtocol);
+
+         stat = asn1PD_H225TunnelledProtocol (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointType                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225EndpointType (OOCTXT* pctxt, H225EndpointType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.vendorPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatekeeperPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatewayPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mcuPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode vendor */
+
+   if (pvalue->m.vendorPresent) {
+      invokeStartElement (pctxt, "vendor", -1);
+
+      stat = asn1PD_H225VendorIdentifier (pctxt, &pvalue->vendor);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "vendor", -1);
+   }
+
+   /* decode gatekeeper */
+
+   if (pvalue->m.gatekeeperPresent) {
+      invokeStartElement (pctxt, "gatekeeper", -1);
+
+      stat = asn1PD_H225GatekeeperInfo (pctxt, &pvalue->gatekeeper);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gatekeeper", -1);
+   }
+
+   /* decode gateway */
+
+   if (pvalue->m.gatewayPresent) {
+      invokeStartElement (pctxt, "gateway", -1);
+
+      stat = asn1PD_H225GatewayInfo (pctxt, &pvalue->gateway);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gateway", -1);
+   }
+
+   /* decode mcu */
+
+   if (pvalue->m.mcuPresent) {
+      invokeStartElement (pctxt, "mcu", -1);
+
+      stat = asn1PD_H225McuInfo (pctxt, &pvalue->mcu);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mcu", -1);
+   }
+
+   /* decode terminal */
+
+   if (pvalue->m.terminalPresent) {
+      invokeStartElement (pctxt, "terminal", -1);
+
+      stat = asn1PD_H225TerminalInfo (pctxt, &pvalue->terminal);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminal", -1);
+   }
+
+   /* decode mc */
+
+   invokeStartElement (pctxt, "mc", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->mc);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->mc);
+
+   invokeEndElement (pctxt, "mc", -1);
+
+   /* decode undefinedNode */
+
+   invokeStartElement (pctxt, "undefinedNode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->undefinedNode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->undefinedNode);
+
+   invokeEndElement (pctxt, "undefinedNode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.setPresent = 1;
+
+                     invokeStartElement (pctxt, "set", -1);
+
+                     stat = asn1PD_H225EndpointType_set (pctxt, &pvalue->set);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "set", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.supportedTunnelledProtocolsPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedTunnelledProtocols", -1);
+
+                     stat = asn1PD_H225_SeqOfH225TunnelledProtocol (pctxt, &pvalue->supportedTunnelledProtocols);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedTunnelledProtocols", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CallReferenceValue                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225CallReferenceValue (OOCTXT* pctxt, H225_SeqOfH225CallReferenceValue* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, H225CallReferenceValue);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_conferenceGoal                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Setup_UUIE_conferenceGoal (OOCTXT* pctxt, H225Setup_UUIE_conferenceGoal* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* create */
+         case 0:
+            invokeStartElement (pctxt, "create", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "create", -1);
+
+            break;
+
+         /* join */
+         case 1:
+            invokeStartElement (pctxt, "join", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "join", -1);
+
+            break;
+
+         /* invite */
+         case 2:
+            invokeStartElement (pctxt, "invite", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invite", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* capability_negotiation */
+         case 4:
+            invokeStartElement (pctxt, "capability_negotiation", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "capability_negotiation", -1);
+
+            break;
+
+         /* callIndependentSupplementaryService */
+         case 5:
+            invokeStartElement (pctxt, "callIndependentSupplementaryService", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "callIndependentSupplementaryService", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q954Details                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Q954Details (OOCTXT* pctxt, H225Q954Details* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode conferenceCalling */
+
+   invokeStartElement (pctxt, "conferenceCalling", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->conferenceCalling);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->conferenceCalling);
+
+   invokeEndElement (pctxt, "conferenceCalling", -1);
+
+   /* decode threePartyService */
+
+   invokeStartElement (pctxt, "threePartyService", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->threePartyService);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->threePartyService);
+
+   invokeEndElement (pctxt, "threePartyService", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  QseriesOptions                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225QseriesOptions (OOCTXT* pctxt, H225QseriesOptions* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode q932Full */
+
+   invokeStartElement (pctxt, "q932Full", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->q932Full);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->q932Full);
+
+   invokeEndElement (pctxt, "q932Full", -1);
+
+   /* decode q951Full */
+
+   invokeStartElement (pctxt, "q951Full", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->q951Full);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->q951Full);
+
+   invokeEndElement (pctxt, "q951Full", -1);
+
+   /* decode q952Full */
+
+   invokeStartElement (pctxt, "q952Full", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->q952Full);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->q952Full);
+
+   invokeEndElement (pctxt, "q952Full", -1);
+
+   /* decode q953Full */
+
+   invokeStartElement (pctxt, "q953Full", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->q953Full);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->q953Full);
+
+   invokeEndElement (pctxt, "q953Full", -1);
+
+   /* decode q955Full */
+
+   invokeStartElement (pctxt, "q955Full", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->q955Full);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->q955Full);
+
+   invokeEndElement (pctxt, "q955Full", -1);
+
+   /* decode q956Full */
+
+   invokeStartElement (pctxt, "q956Full", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->q956Full);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->q956Full);
+
+   invokeEndElement (pctxt, "q956Full", -1);
+
+   /* decode q957Full */
+
+   invokeStartElement (pctxt, "q957Full", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->q957Full);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->q957Full);
+
+   invokeEndElement (pctxt, "q957Full", -1);
+
+   /* decode q954Info */
+
+   invokeStartElement (pctxt, "q954Info", -1);
+
+   stat = asn1PD_H225Q954Details (pctxt, &pvalue->q954Info);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "q954Info", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallType                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallType (OOCTXT* pctxt, H225CallType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* pointToPoint */
+         case 0:
+            invokeStartElement (pctxt, "pointToPoint", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "pointToPoint", -1);
+
+            break;
+
+         /* oneToN */
+         case 1:
+            invokeStartElement (pctxt, "oneToN", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "oneToN", -1);
+
+            break;
+
+         /* nToOne */
+         case 2:
+            invokeStartElement (pctxt, "nToOne", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nToOne", -1);
+
+            break;
+
+         /* nToN */
+         case 3:
+            invokeStartElement (pctxt, "nToN", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nToN", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallIdentifier                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallIdentifier (OOCTXT* pctxt, H225CallIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode guid */
+
+   invokeStartElement (pctxt, "guid", -1);
+
+   stat = asn1PD_H225GloballyUniqueID (pctxt, &pvalue->guid);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "guid", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityServiceMode                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225SecurityServiceMode (OOCTXT* pctxt, H225SecurityServiceMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
+
+            stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* none */
+         case 1:
+            invokeStartElement (pctxt, "none", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "none", -1);
+
+            break;
+
+         /* default_ */
+         case 2:
+            invokeStartElement (pctxt, "default_", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "default_", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityCapabilities                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilities* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   /* decode encryption */
+
+   invokeStartElement (pctxt, "encryption", -1);
+
+   stat = asn1PD_H225SecurityServiceMode (pctxt, &pvalue->encryption);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "encryption", -1);
+
+   /* decode authenticaton */
+
+   invokeStartElement (pctxt, "authenticaton", -1);
+
+   stat = asn1PD_H225SecurityServiceMode (pctxt, &pvalue->authenticaton);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "authenticaton", -1);
+
+   /* decode integrity */
+
+   invokeStartElement (pctxt, "integrity", -1);
+
+   stat = asn1PD_H225SecurityServiceMode (pctxt, &pvalue->integrity);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "integrity", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H245Security                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H245Security (OOCTXT* pctxt, H225H245Security* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
+
+            stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* noSecurity */
+         case 1:
+            invokeStartElement (pctxt, "noSecurity", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noSecurity", -1);
+
+            break;
+
+         /* tls */
+         case 2:
+            invokeStartElement (pctxt, "tls", -1);
+
+            pvalue->u.tls = ALLOC_ASN1ELEM (pctxt, H225SecurityCapabilities);
+
+            stat = asn1PD_H225SecurityCapabilities (pctxt, pvalue->u.tls);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "tls", -1);
+
+            break;
+
+         /* ipsec */
+         case 3:
+            invokeStartElement (pctxt, "ipsec", -1);
+
+            pvalue->u.ipsec = ALLOC_ASN1ELEM (pctxt, H225SecurityCapabilities);
+
+            stat = asn1PD_H225SecurityCapabilities (pctxt, pvalue->u.ipsec);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "ipsec", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225H245Security                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225H245Security (OOCTXT* pctxt, H225_SeqOfH225H245Security* pvalue)
+{
+   int stat = ASN_OK;
+   H225H245Security* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225H245Security);
+
+         stat = asn1PD_H225H245Security (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ClearToken                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225ClearToken (OOCTXT* pctxt, H225_SeqOfH225ClearToken* pvalue)
+{
+   int stat = ASN_OK;
+   H235ClearToken* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H235ClearToken);
+
+         stat = asn1PD_H235ClearToken (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoEPPwdHash                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoEPPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPPwdHash* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode alias */
+
+   invokeStartElement (pctxt, "alias", -1);
+
+   stat = asn1PD_H225AliasAddress (pctxt, &pvalue->alias);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "alias", -1);
+
+   /* decode timeStamp */
+
+   invokeStartElement (pctxt, "timeStamp", -1);
+
+   stat = asn1PD_H235TimeStamp (pctxt, &pvalue->timeStamp);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "timeStamp", -1);
+
+   /* decode token */
+
+   invokeStartElement (pctxt, "token", -1);
+
+   stat = asn1PD_H235HASHED (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "token", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoGKPwdHash                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoGKPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKPwdHash* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode gatekeeperId */
+
+   invokeStartElement (pctxt, "gatekeeperId", -1);
+
+   stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperId);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "gatekeeperId", -1);
+
+   /* decode timeStamp */
+
+   invokeStartElement (pctxt, "timeStamp", -1);
+
+   stat = asn1PD_H235TimeStamp (pctxt, &pvalue->timeStamp);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "timeStamp", -1);
+
+   /* decode token */
+
+   invokeStartElement (pctxt, "token", -1);
+
+   stat = asn1PD_H235HASHED (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "token", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoEPCert                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoEPCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPCert* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode toBeSigned */
+
+   invokeStartElement (pctxt, "toBeSigned", -1);
+
+   stat = asn1PD_H235EncodedPwdCertToken (pctxt, &pvalue->toBeSigned);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "toBeSigned", -1);
+
+   /* decode algorithmOID */
+
+   invokeStartElement (pctxt, "algorithmOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
+
+   invokeEndElement (pctxt, "algorithmOID", -1);
+
+   /* decode paramS */
+
+   invokeStartElement (pctxt, "paramS", -1);
+
+   stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "paramS", -1);
+
+   /* decode signature */
+
+   invokeStartElement (pctxt, "signature", -1);
+
+   stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->signature);
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->signature.numbits, pvalue->signature.data);
+
+   invokeEndElement (pctxt, "signature", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoGKCert                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoGKCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKCert* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode toBeSigned */
+
+   invokeStartElement (pctxt, "toBeSigned", -1);
+
+   stat = asn1PD_H235EncodedPwdCertToken (pctxt, &pvalue->toBeSigned);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "toBeSigned", -1);
+
+   /* decode algorithmOID */
+
+   invokeStartElement (pctxt, "algorithmOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
+
+   invokeEndElement (pctxt, "algorithmOID", -1);
+
+   /* decode paramS */
+
+   invokeStartElement (pctxt, "paramS", -1);
+
+   stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "paramS", -1);
+
+   /* decode signature */
+
+   invokeStartElement (pctxt, "signature", -1);
+
+   stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->signature);
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->signature.numbits, pvalue->signature.data);
+
+   invokeEndElement (pctxt, "signature", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoFastStart                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CryptoH323Token_cryptoFastStart (OOCTXT* pctxt, H225CryptoH323Token_cryptoFastStart* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode toBeSigned */
+
+   invokeStartElement (pctxt, "toBeSigned", -1);
+
+   stat = asn1PD_H225EncodedFastStartToken (pctxt, &pvalue->toBeSigned);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "toBeSigned", -1);
+
+   /* decode algorithmOID */
+
+   invokeStartElement (pctxt, "algorithmOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
+
+   invokeEndElement (pctxt, "algorithmOID", -1);
+
+   /* decode paramS */
+
+   invokeStartElement (pctxt, "paramS", -1);
+
+   stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "paramS", -1);
+
+   /* decode signature */
+
+   invokeStartElement (pctxt, "signature", -1);
+
+   stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->signature);
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->signature.numbits, pvalue->signature.data);
+
+   invokeEndElement (pctxt, "signature", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CryptoH323Token (OOCTXT* pctxt, H225CryptoH323Token* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* cryptoEPPwdHash */
+         case 0:
+            invokeStartElement (pctxt, "cryptoEPPwdHash", -1);
+
+            pvalue->u.cryptoEPPwdHash = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoEPPwdHash);
+
+            stat = asn1PD_H225CryptoH323Token_cryptoEPPwdHash (pctxt, pvalue->u.cryptoEPPwdHash);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoEPPwdHash", -1);
+
+            break;
+
+         /* cryptoGKPwdHash */
+         case 1:
+            invokeStartElement (pctxt, "cryptoGKPwdHash", -1);
+
+            pvalue->u.cryptoGKPwdHash = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoGKPwdHash);
+
+            stat = asn1PD_H225CryptoH323Token_cryptoGKPwdHash (pctxt, pvalue->u.cryptoGKPwdHash);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoGKPwdHash", -1);
+
+            break;
+
+         /* cryptoEPPwdEncr */
+         case 2:
+            invokeStartElement (pctxt, "cryptoEPPwdEncr", -1);
+
+            pvalue->u.cryptoEPPwdEncr = ALLOC_ASN1ELEM (pctxt, H235ENCRYPTED);
+
+            stat = asn1PD_H235ENCRYPTED (pctxt, pvalue->u.cryptoEPPwdEncr);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoEPPwdEncr", -1);
+
+            break;
+
+         /* cryptoGKPwdEncr */
+         case 3:
+            invokeStartElement (pctxt, "cryptoGKPwdEncr", -1);
+
+            pvalue->u.cryptoGKPwdEncr = ALLOC_ASN1ELEM (pctxt, H235ENCRYPTED);
+
+            stat = asn1PD_H235ENCRYPTED (pctxt, pvalue->u.cryptoGKPwdEncr);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoGKPwdEncr", -1);
+
+            break;
+
+         /* cryptoEPCert */
+         case 4:
+            invokeStartElement (pctxt, "cryptoEPCert", -1);
+
+            pvalue->u.cryptoEPCert = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoEPCert);
+
+            stat = asn1PD_H225CryptoH323Token_cryptoEPCert (pctxt, pvalue->u.cryptoEPCert);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoEPCert", -1);
+
+            break;
+
+         /* cryptoGKCert */
+         case 5:
+            invokeStartElement (pctxt, "cryptoGKCert", -1);
+
+            pvalue->u.cryptoGKCert = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoGKCert);
+
+            stat = asn1PD_H225CryptoH323Token_cryptoGKCert (pctxt, pvalue->u.cryptoGKCert);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoGKCert", -1);
+
+            break;
+
+         /* cryptoFastStart */
+         case 6:
+            invokeStartElement (pctxt, "cryptoFastStart", -1);
+
+            pvalue->u.cryptoFastStart = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoFastStart);
+
+            stat = asn1PD_H225CryptoH323Token_cryptoFastStart (pctxt, pvalue->u.cryptoFastStart);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cryptoFastStart", -1);
+
+            break;
+
+         /* nestedcryptoToken */
+         case 7:
+            invokeStartElement (pctxt, "nestedcryptoToken", -1);
+
+            pvalue->u.nestedcryptoToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken);
+
+            stat = asn1PD_H235CryptoToken (pctxt, pvalue->u.nestedcryptoToken);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nestedcryptoToken", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 9;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CryptoH323Token                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225CryptoH323Token (OOCTXT* pctxt, H225_SeqOfH225CryptoH323Token* pvalue)
+{
+   int stat = ASN_OK;
+   H225CryptoH323Token* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225CryptoH323Token);
+
+         stat = asn1PD_H225CryptoH323Token (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_fastStart                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Setup_UUIE_fastStart (OOCTXT* pctxt, H225Setup_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ScnConnectionType                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ScnConnectionType (OOCTXT* pctxt, H225ScnConnectionType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unknown */
+         case 0:
+            invokeStartElement (pctxt, "unknown", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unknown", -1);
+
+            break;
+
+         /* bChannel */
+         case 1:
+            invokeStartElement (pctxt, "bChannel", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "bChannel", -1);
+
+            break;
+
+         /* hybrid2x64 */
+         case 2:
+            invokeStartElement (pctxt, "hybrid2x64", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hybrid2x64", -1);
+
+            break;
+
+         /* hybrid384 */
+         case 3:
+            invokeStartElement (pctxt, "hybrid384", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hybrid384", -1);
+
+            break;
+
+         /* hybrid1536 */
+         case 4:
+            invokeStartElement (pctxt, "hybrid1536", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hybrid1536", -1);
+
+            break;
+
+         /* hybrid1920 */
+         case 5:
+            invokeStartElement (pctxt, "hybrid1920", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hybrid1920", -1);
+
+            break;
+
+         /* multirate */
+         case 6:
+            invokeStartElement (pctxt, "multirate", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "multirate", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 8;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ScnConnectionAggregation                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ScnConnectionAggregation (OOCTXT* pctxt, H225ScnConnectionAggregation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* auto_ */
+         case 0:
+            invokeStartElement (pctxt, "auto_", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "auto_", -1);
+
+            break;
+
+         /* none */
+         case 1:
+            invokeStartElement (pctxt, "none", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "none", -1);
+
+            break;
+
+         /* h221 */
+         case 2:
+            invokeStartElement (pctxt, "h221", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "h221", -1);
+
+            break;
+
+         /* bonded_mode1 */
+         case 3:
+            invokeStartElement (pctxt, "bonded_mode1", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "bonded_mode1", -1);
+
+            break;
+
+         /* bonded_mode2 */
+         case 4:
+            invokeStartElement (pctxt, "bonded_mode2", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "bonded_mode2", -1);
+
+            break;
+
+         /* bonded_mode3 */
+         case 5:
+            invokeStartElement (pctxt, "bonded_mode3", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "bonded_mode3", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_connectionParameters                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Setup_UUIE_connectionParameters (OOCTXT* pctxt, H225Setup_UUIE_connectionParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode connectionType */
+
+   invokeStartElement (pctxt, "connectionType", -1);
+
+   stat = asn1PD_H225ScnConnectionType (pctxt, &pvalue->connectionType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "connectionType", -1);
+
+   /* decode numberOfScnConnections */
+
+   invokeStartElement (pctxt, "numberOfScnConnections", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->numberOfScnConnections, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfScnConnections);
+
+   invokeEndElement (pctxt, "numberOfScnConnections", -1);
+
+   /* decode connectionAggregation */
+
+   invokeStartElement (pctxt, "connectionAggregation", -1);
+
+   stat = asn1PD_H225ScnConnectionAggregation (pctxt, &pvalue->connectionAggregation);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "connectionAggregation", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_language                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Setup_UUIE_language (OOCTXT* pctxt, H225Setup_UUIE_language* pvalue)
+{
+   static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1IA5String);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      addSizeConstraint (pctxt, &element_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->elem[xx1], 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->elem[xx1]);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PresentationIndicator                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225PresentationIndicator (OOCTXT* pctxt, H225PresentationIndicator* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* presentationAllowed */
+         case 0:
+            invokeStartElement (pctxt, "presentationAllowed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "presentationAllowed", -1);
+
+            break;
+
+         /* presentationRestricted */
+         case 1:
+            invokeStartElement (pctxt, "presentationRestricted", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "presentationRestricted", -1);
+
+            break;
+
+         /* addressNotAvailable */
+         case 2:
+            invokeStartElement (pctxt, "addressNotAvailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "addressNotAvailable", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl_billingMode                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallCreditServiceControl_billingMode (OOCTXT* pctxt, H225CallCreditServiceControl_billingMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* credit */
+         case 0:
+            invokeStartElement (pctxt, "credit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "credit", -1);
+
+            break;
+
+         /* debit */
+         case 1:
+            invokeStartElement (pctxt, "debit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "debit", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl_callStartingPoint                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallCreditServiceControl_callStartingPoint (OOCTXT* pctxt, H225CallCreditServiceControl_callStartingPoint* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* alerting */
+         case 0:
+            invokeStartElement (pctxt, "alerting", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "alerting", -1);
+
+            break;
+
+         /* connect */
+         case 1:
+            invokeStartElement (pctxt, "connect", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "connect", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallCreditServiceControl (OOCTXT* pctxt, H225CallCreditServiceControl* pvalue)
+{
+   static Asn1SizeCnst amountString_lsize1 = { 0, 1, 512, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.amountStringPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.billingModePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callDurationLimitPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.enforceCallDurationLimitPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callStartingPointPresent = optbit;
+
+   /* decode amountString */
+
+   if (pvalue->m.amountStringPresent) {
+      invokeStartElement (pctxt, "amountString", -1);
+
+      addSizeConstraint (pctxt, &amountString_lsize1);
+
+      stat = decodeBMPString (pctxt, &pvalue->amountString, 0);
+      if (stat != ASN_OK) return stat;
+      invokeCharStr16BitValue (pctxt, pvalue->amountString.nchars, pvalue->amountString.data);
+
+      invokeEndElement (pctxt, "amountString", -1);
+   }
+
+   /* decode billingMode */
+
+   if (pvalue->m.billingModePresent) {
+      invokeStartElement (pctxt, "billingMode", -1);
+
+      stat = asn1PD_H225CallCreditServiceControl_billingMode (pctxt, &pvalue->billingMode);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "billingMode", -1);
+   }
+
+   /* decode callDurationLimit */
+
+   if (pvalue->m.callDurationLimitPresent) {
+      invokeStartElement (pctxt, "callDurationLimit", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->callDurationLimit, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->callDurationLimit);
+
+      invokeEndElement (pctxt, "callDurationLimit", -1);
+   }
+
+   /* decode enforceCallDurationLimit */
+
+   if (pvalue->m.enforceCallDurationLimitPresent) {
+      invokeStartElement (pctxt, "enforceCallDurationLimit", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->enforceCallDurationLimit);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->enforceCallDurationLimit);
+
+      invokeEndElement (pctxt, "enforceCallDurationLimit", -1);
+   }
+
+   /* decode callStartingPoint */
+
+   if (pvalue->m.callStartingPointPresent) {
+      invokeStartElement (pctxt, "callStartingPoint", -1);
+
+      stat = asn1PD_H225CallCreditServiceControl_callStartingPoint (pctxt, &pvalue->callStartingPoint);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callStartingPoint", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlDescriptor                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ServiceControlDescriptor (OOCTXT* pctxt, H225ServiceControlDescriptor* pvalue)
+{
+   static Asn1SizeCnst url_lsize1 = { 0, 0, 512, 0 };
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* url */
+         case 0:
+            invokeStartElement (pctxt, "url", -1);
+
+            addSizeConstraint (pctxt, &url_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.url, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.url);
+
+            invokeEndElement (pctxt, "url", -1);
+
+            break;
+
+         /* signal */
+         case 1:
+            invokeStartElement (pctxt, "signal", -1);
+
+            pvalue->u.signal = ALLOC_ASN1ELEM (pctxt, H225H248SignalsDescriptor);
+
+            stat = asn1PD_H225H248SignalsDescriptor (pctxt, pvalue->u.signal);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "signal", -1);
+
+            break;
+
+         /* nonStandard */
+         case 2:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
+
+            stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* callCreditServiceControl */
+         case 3:
+            invokeStartElement (pctxt, "callCreditServiceControl", -1);
+
+            pvalue->u.callCreditServiceControl = ALLOC_ASN1ELEM (pctxt, H225CallCreditServiceControl);
+
+            stat = asn1PD_H225CallCreditServiceControl (pctxt, pvalue->u.callCreditServiceControl);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "callCreditServiceControl", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlSession_reason                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ServiceControlSession_reason (OOCTXT* pctxt, H225ServiceControlSession_reason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* open */
+         case 0:
+            invokeStartElement (pctxt, "open", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "open", -1);
+
+            break;
+
+         /* refresh */
+         case 1:
+            invokeStartElement (pctxt, "refresh", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "refresh", -1);
+
+            break;
+
+         /* close */
+         case 2:
+            invokeStartElement (pctxt, "close", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "close", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlSession                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ServiceControlSession (OOCTXT* pctxt, H225ServiceControlSession* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.contentsPresent = optbit;
+
+   /* decode sessionId */
+
+   invokeStartElement (pctxt, "sessionId", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sessionId, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sessionId);
+
+   invokeEndElement (pctxt, "sessionId", -1);
+
+   /* decode contents */
+
+   if (pvalue->m.contentsPresent) {
+      invokeStartElement (pctxt, "contents", -1);
+
+      stat = asn1PD_H225ServiceControlDescriptor (pctxt, &pvalue->contents);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "contents", -1);
+   }
+
+   /* decode reason */
+
+   invokeStartElement (pctxt, "reason", -1);
+
+   stat = asn1PD_H225ServiceControlSession_reason (pctxt, &pvalue->reason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "reason", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ServiceControlSession                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225ServiceControlSession (OOCTXT* pctxt, H225_SeqOfH225ServiceControlSession* pvalue)
+{
+   int stat = ASN_OK;
+   H225ServiceControlSession* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225ServiceControlSession);
+
+         stat = asn1PD_H225ServiceControlSession (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CarrierInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CarrierInfo (OOCTXT* pctxt, H225CarrierInfo* pvalue)
+{
+   static Asn1SizeCnst carrierName_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.carrierIdentificationCodePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.carrierNamePresent = optbit;
+
+   /* decode carrierIdentificationCode */
+
+   if (pvalue->m.carrierIdentificationCodePresent) {
+      invokeStartElement (pctxt, "carrierIdentificationCode", -1);
+
+      stat = asn1PD_H225CarrierInfo_carrierIdentificationCode (pctxt, &pvalue->carrierIdentificationCode);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "carrierIdentificationCode", -1);
+   }
+
+   /* decode carrierName */
+
+   if (pvalue->m.carrierNamePresent) {
+      invokeStartElement (pctxt, "carrierName", -1);
+
+      addSizeConstraint (pctxt, &carrierName_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->carrierName, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->carrierName);
+
+      invokeEndElement (pctxt, "carrierName", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallsAvailable                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallsAvailable (OOCTXT* pctxt, H225CallsAvailable* pvalue)
+{
+   static Asn1SizeCnst group_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.groupPresent = optbit;
+
+   /* decode calls */
+
+   invokeStartElement (pctxt, "calls", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->calls, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->calls);
+
+   invokeEndElement (pctxt, "calls", -1);
+
+   /* decode group */
+
+   if (pvalue->m.groupPresent) {
+      invokeStartElement (pctxt, "group", -1);
+
+      addSizeConstraint (pctxt, &group_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->group, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->group);
+
+      invokeEndElement (pctxt, "group", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.carrierPresent = 1;
+
+                     invokeStartElement (pctxt, "carrier", -1);
+
+                     stat = asn1PD_H225CarrierInfo (pctxt, &pvalue->carrier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "carrier", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CallsAvailable                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225CallsAvailable (OOCTXT* pctxt, H225_SeqOfH225CallsAvailable* pvalue)
+{
+   int stat = ASN_OK;
+   H225CallsAvailable* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225CallsAvailable);
+
+         stat = asn1PD_H225CallsAvailable (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCapacityInfo                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallCapacityInfo (OOCTXT* pctxt, H225CallCapacityInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.voiceGwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h310GwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h320GwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h321GwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h322GwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h323GwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h324GwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.t120OnlyGwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.t38FaxAnnexbOnlyGwCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalCallsAvailablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mcuCallsAvailablePresent = optbit;
+
+   /* decode voiceGwCallsAvailable */
+
+   if (pvalue->m.voiceGwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "voiceGwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->voiceGwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "voiceGwCallsAvailable", -1);
+   }
+
+   /* decode h310GwCallsAvailable */
+
+   if (pvalue->m.h310GwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "h310GwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h310GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h310GwCallsAvailable", -1);
+   }
+
+   /* decode h320GwCallsAvailable */
+
+   if (pvalue->m.h320GwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "h320GwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h320GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h320GwCallsAvailable", -1);
+   }
+
+   /* decode h321GwCallsAvailable */
+
+   if (pvalue->m.h321GwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "h321GwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h321GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h321GwCallsAvailable", -1);
+   }
+
+   /* decode h322GwCallsAvailable */
+
+   if (pvalue->m.h322GwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "h322GwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h322GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h322GwCallsAvailable", -1);
+   }
+
+   /* decode h323GwCallsAvailable */
+
+   if (pvalue->m.h323GwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "h323GwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h323GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h323GwCallsAvailable", -1);
+   }
+
+   /* decode h324GwCallsAvailable */
+
+   if (pvalue->m.h324GwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "h324GwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h324GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h324GwCallsAvailable", -1);
+   }
+
+   /* decode t120OnlyGwCallsAvailable */
+
+   if (pvalue->m.t120OnlyGwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "t120OnlyGwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->t120OnlyGwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "t120OnlyGwCallsAvailable", -1);
+   }
+
+   /* decode t38FaxAnnexbOnlyGwCallsAvailable */
+
+   if (pvalue->m.t38FaxAnnexbOnlyGwCallsAvailablePresent) {
+      invokeStartElement (pctxt, "t38FaxAnnexbOnlyGwCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->t38FaxAnnexbOnlyGwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "t38FaxAnnexbOnlyGwCallsAvailable", -1);
+   }
+
+   /* decode terminalCallsAvailable */
+
+   if (pvalue->m.terminalCallsAvailablePresent) {
+      invokeStartElement (pctxt, "terminalCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->terminalCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminalCallsAvailable", -1);
+   }
+
+   /* decode mcuCallsAvailable */
+
+   if (pvalue->m.mcuCallsAvailablePresent) {
+      invokeStartElement (pctxt, "mcuCallsAvailable", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->mcuCallsAvailable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mcuCallsAvailable", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.sipGwCallsAvailablePresent = 1;
+
+                     invokeStartElement (pctxt, "sipGwCallsAvailable", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->sipGwCallsAvailable);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "sipGwCallsAvailable", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCapacity                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallCapacity (OOCTXT* pctxt, H225CallCapacity* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.maximumCallCapacityPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.currentCallCapacityPresent = optbit;
+
+   /* decode maximumCallCapacity */
+
+   if (pvalue->m.maximumCallCapacityPresent) {
+      invokeStartElement (pctxt, "maximumCallCapacity", -1);
+
+      stat = asn1PD_H225CallCapacityInfo (pctxt, &pvalue->maximumCallCapacity);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "maximumCallCapacity", -1);
+   }
+
+   /* decode currentCallCapacity */
+
+   if (pvalue->m.currentCallCapacityPresent) {
+      invokeStartElement (pctxt, "currentCallCapacity", -1);
+
+      stat = asn1PD_H225CallCapacityInfo (pctxt, &pvalue->currentCallCapacity);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "currentCallCapacity", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CicInfo_cic_element                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225CicInfo_cic_element (OOCTXT* pctxt, H225_SeqOfH225CicInfo_cic_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, H225CicInfo_cic_element);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H225CicInfo_cic_element (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CicInfo (OOCTXT* pctxt, H225CicInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode cic */
+
+   invokeStartElement (pctxt, "cic", -1);
+
+   stat = asn1PD_H225_SeqOfH225CicInfo_cic_element (pctxt, &pvalue->cic);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cic", -1);
+
+   /* decode pointCode */
+
+   invokeStartElement (pctxt, "pointCode", -1);
+
+   stat = asn1PD_H225CicInfo_pointCode (pctxt, &pvalue->pointCode);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "pointCode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GroupID_member                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GroupID_member (OOCTXT* pctxt, H225GroupID_member* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1USINT);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->elem[xx1], 0U, 65535U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->elem[xx1]);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GroupID                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GroupID (OOCTXT* pctxt, H225GroupID* pvalue)
+{
+   static Asn1SizeCnst group_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.memberPresent = optbit;
+
+   /* decode member */
+
+   if (pvalue->m.memberPresent) {
+      invokeStartElement (pctxt, "member", -1);
+
+      stat = asn1PD_H225GroupID_member (pctxt, &pvalue->member);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "member", -1);
+   }
+
+   /* decode group */
+
+   invokeStartElement (pctxt, "group", -1);
+
+   addSizeConstraint (pctxt, &group_lsize1);
+
+   stat = decodeConstrainedStringEx (pctxt, &pvalue->group, 0, 8, 7, 7);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, pvalue->group);
+
+   invokeEndElement (pctxt, "group", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CircuitIdentifier                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CircuitIdentifier (OOCTXT* pctxt, H225CircuitIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cicPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.groupPresent = optbit;
+
+   /* decode cic */
+
+   if (pvalue->m.cicPresent) {
+      invokeStartElement (pctxt, "cic", -1);
+
+      stat = asn1PD_H225CicInfo (pctxt, &pvalue->cic);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cic", -1);
+   }
+
+   /* decode group */
+
+   if (pvalue->m.groupPresent) {
+      invokeStartElement (pctxt, "group", -1);
+
+      stat = asn1PD_H225GroupID (pctxt, &pvalue->group);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "group", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.carrierPresent = 1;
+
+                     invokeStartElement (pctxt, "carrier", -1);
+
+                     stat = asn1PD_H225CarrierInfo (pctxt, &pvalue->carrier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "carrier", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225GenericData                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225GenericData (OOCTXT* pctxt, H225_SeqOfH225GenericData* pvalue)
+{
+   int stat = ASN_OK;
+   H225GenericData* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225GenericData);
+
+         stat = asn1PD_H225GenericData (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CircuitInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CircuitInfo (OOCTXT* pctxt, H225CircuitInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sourceCircuitIDPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destinationCircuitIDPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.genericDataPresent = optbit;
+
+   /* decode sourceCircuitID */
+
+   if (pvalue->m.sourceCircuitIDPresent) {
+      invokeStartElement (pctxt, "sourceCircuitID", -1);
+
+      stat = asn1PD_H225CircuitIdentifier (pctxt, &pvalue->sourceCircuitID);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "sourceCircuitID", -1);
+   }
+
+   /* decode destinationCircuitID */
+
+   if (pvalue->m.destinationCircuitIDPresent) {
+      invokeStartElement (pctxt, "destinationCircuitID", -1);
+
+      stat = asn1PD_H225CircuitIdentifier (pctxt, &pvalue->destinationCircuitID);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destinationCircuitID", -1);
+   }
+
+   /* decode genericData */
+
+   if (pvalue->m.genericDataPresent) {
+      invokeStartElement (pctxt, "genericData", -1);
+
+      stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "genericData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225FeatureDescriptor                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225FeatureDescriptor (OOCTXT* pctxt, H225_SeqOfH225FeatureDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+   H225FeatureDescriptor* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225FeatureDescriptor);
+
+         stat = asn1PD_H225FeatureDescriptor (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_parallelH245Control                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Setup_UUIE_parallelH245Control (OOCTXT* pctxt, H225Setup_UUIE_parallelH245Control* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ExtendedAliasAddress                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ExtendedAliasAddress (OOCTXT* pctxt, H225ExtendedAliasAddress* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.presentationIndicatorPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.screeningIndicatorPresent = optbit;
+
+   /* decode address */
+
+   invokeStartElement (pctxt, "address", -1);
+
+   stat = asn1PD_H225AliasAddress (pctxt, &pvalue->address);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "address", -1);
+
+   /* decode presentationIndicator */
+
+   if (pvalue->m.presentationIndicatorPresent) {
+      invokeStartElement (pctxt, "presentationIndicator", -1);
+
+      stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "presentationIndicator", -1);
+   }
+
+   /* decode screeningIndicator */
+
+   if (pvalue->m.screeningIndicatorPresent) {
+      invokeStartElement (pctxt, "screeningIndicator", -1);
+
+      stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "screeningIndicator", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ExtendedAliasAddress                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225ExtendedAliasAddress (OOCTXT* pctxt, H225_SeqOfH225ExtendedAliasAddress* pvalue)
+{
+   int stat = ASN_OK;
+   H225ExtendedAliasAddress* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225ExtendedAliasAddress);
+
+         stat = asn1PD_H225ExtendedAliasAddress (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Setup_UUIE (OOCTXT* pctxt, H225Setup_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h245AddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sourceAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destinationAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destCallSignalAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destExtraCallInfoPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destExtraCRVPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callServicesPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      invokeStartElement (pctxt, "h245Address", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h245Address", -1);
+   }
+
+   /* decode sourceAddress */
+
+   if (pvalue->m.sourceAddressPresent) {
+      invokeStartElement (pctxt, "sourceAddress", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->sourceAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "sourceAddress", -1);
+   }
+
+   /* decode sourceInfo */
+
+   invokeStartElement (pctxt, "sourceInfo", -1);
+
+   stat = asn1PD_H225EndpointType (pctxt, &pvalue->sourceInfo);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sourceInfo", -1);
+
+   /* decode destinationAddress */
+
+   if (pvalue->m.destinationAddressPresent) {
+      invokeStartElement (pctxt, "destinationAddress", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destinationAddress", -1);
+   }
+
+   /* decode destCallSignalAddress */
+
+   if (pvalue->m.destCallSignalAddressPresent) {
+      invokeStartElement (pctxt, "destCallSignalAddress", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destCallSignalAddress", -1);
+   }
+
+   /* decode destExtraCallInfo */
+
+   if (pvalue->m.destExtraCallInfoPresent) {
+      invokeStartElement (pctxt, "destExtraCallInfo", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destExtraCallInfo", -1);
+   }
+
+   /* decode destExtraCRV */
+
+   if (pvalue->m.destExtraCRVPresent) {
+      invokeStartElement (pctxt, "destExtraCRV", -1);
+
+      stat = asn1PD_H225_SeqOfH225CallReferenceValue (pctxt, &pvalue->destExtraCRV);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destExtraCRV", -1);
+   }
+
+   /* decode activeMC */
+
+   invokeStartElement (pctxt, "activeMC", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->activeMC);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->activeMC);
+
+   invokeEndElement (pctxt, "activeMC", -1);
+
+   /* decode conferenceID */
+
+   invokeStartElement (pctxt, "conferenceID", -1);
+
+   stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceID", -1);
+
+   /* decode conferenceGoal */
+
+   invokeStartElement (pctxt, "conferenceGoal", -1);
+
+   stat = asn1PD_H225Setup_UUIE_conferenceGoal (pctxt, &pvalue->conferenceGoal);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceGoal", -1);
+
+   /* decode callServices */
+
+   if (pvalue->m.callServicesPresent) {
+      invokeStartElement (pctxt, "callServices", -1);
+
+      stat = asn1PD_H225QseriesOptions (pctxt, &pvalue->callServices);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callServices", -1);
+   }
+
+   /* decode callType */
+
+   invokeStartElement (pctxt, "callType", -1);
+
+   stat = asn1PD_H225CallType (pctxt, &pvalue->callType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callType", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 27 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.sourceCallSignalAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "sourceCallSignalAddress", -1);
+
+                     stat = asn1PD_H225TransportAddress (pctxt, &pvalue->sourceCallSignalAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "sourceCallSignalAddress", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.remoteExtensionAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "remoteExtensionAddress", -1);
+
+                     stat = asn1PD_H225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "remoteExtensionAddress", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.h245SecurityCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "h245SecurityCapability", -1);
+
+                     stat = asn1PD_H225_SeqOfH225H245Security (pctxt, &pvalue->h245SecurityCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h245SecurityCapability", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.fastStartPresent = 1;
+
+                     invokeStartElement (pctxt, "fastStart", -1);
+
+                     stat = asn1PD_H225Setup_UUIE_fastStart (pctxt, &pvalue->fastStart);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "fastStart", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.mediaWaitForConnectPresent = 1;
+
+                     invokeStartElement (pctxt, "mediaWaitForConnect", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->mediaWaitForConnect);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->mediaWaitForConnect);
+
+                     invokeEndElement (pctxt, "mediaWaitForConnect", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.canOverlapSendPresent = 1;
+
+                     invokeStartElement (pctxt, "canOverlapSend", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->canOverlapSend);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->canOverlapSend);
+
+                     invokeEndElement (pctxt, "canOverlapSend", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.endpointIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+                     stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "endpointIdentifier", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.maintainConnectionPresent = 1;
+
+                     invokeStartElement (pctxt, "maintainConnection", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maintainConnection);
+
+                     invokeEndElement (pctxt, "maintainConnection", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.connectionParametersPresent = 1;
+
+                     invokeStartElement (pctxt, "connectionParameters", -1);
+
+                     stat = asn1PD_H225Setup_UUIE_connectionParameters (pctxt, &pvalue->connectionParameters);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "connectionParameters", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.languagePresent = 1;
+
+                     invokeStartElement (pctxt, "language", -1);
+
+                     stat = asn1PD_H225Setup_UUIE_language (pctxt, &pvalue->language);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "language", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.presentationIndicatorPresent = 1;
+
+                     invokeStartElement (pctxt, "presentationIndicator", -1);
+
+                     stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "presentationIndicator", -1);
+                     break;
+
+                  case 15:
+                     pvalue->m.screeningIndicatorPresent = 1;
+
+                     invokeStartElement (pctxt, "screeningIndicator", -1);
+
+                     stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "screeningIndicator", -1);
+                     break;
+
+                  case 16:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 17:
+                     pvalue->m.symmetricOperationRequiredPresent = 1;
+
+                     invokeStartElement (pctxt, "symmetricOperationRequired", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "symmetricOperationRequired", -1);
+                     break;
+
+                  case 18:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 19:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 20:
+                     pvalue->m.desiredProtocolsPresent = 1;
+
+                     invokeStartElement (pctxt, "desiredProtocols", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->desiredProtocols);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "desiredProtocols", -1);
+                     break;
+
+                  case 21:
+                     pvalue->m.neededFeaturesPresent = 1;
+
+                     invokeStartElement (pctxt, "neededFeatures", -1);
+
+                     stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->neededFeatures);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "neededFeatures", -1);
+                     break;
+
+                  case 22:
+                     pvalue->m.desiredFeaturesPresent = 1;
+
+                     invokeStartElement (pctxt, "desiredFeatures", -1);
+
+                     stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->desiredFeatures);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "desiredFeatures", -1);
+                     break;
+
+                  case 23:
+                     pvalue->m.supportedFeaturesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedFeatures", -1);
+
+                     stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->supportedFeatures);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedFeatures", -1);
+                     break;
+
+                  case 24:
+                     pvalue->m.parallelH245ControlPresent = 1;
+
+                     invokeStartElement (pctxt, "parallelH245Control", -1);
+
+                     stat = asn1PD_H225Setup_UUIE_parallelH245Control (pctxt, &pvalue->parallelH245Control);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "parallelH245Control", -1);
+                     break;
+
+                  case 25:
+                     pvalue->m.additionalSourceAddressesPresent = 1;
+
+                     invokeStartElement (pctxt, "additionalSourceAddresses", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ExtendedAliasAddress (pctxt, &pvalue->additionalSourceAddresses);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "additionalSourceAddresses", -1);
+                     break;
+
+                  case 26:
+                     pvalue->m.hopCountPresent = 1;
+
+                     invokeStartElement (pctxt, "hopCount", -1);
+
+                     stat = decodeConsUInt8 (pctxt, &pvalue->hopCount, 1U, 31U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->hopCount);
+
+                     invokeEndElement (pctxt, "hopCount", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallProceeding_UUIE_fastStart                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallProceeding_UUIE_fastStart (OOCTXT* pctxt, H225CallProceeding_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FeatureSet                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225FeatureSet (OOCTXT* pctxt, H225FeatureSet* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.neededFeaturesPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.desiredFeaturesPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.supportedFeaturesPresent = optbit;
+
+   /* decode replacementFeatureSet */
+
+   invokeStartElement (pctxt, "replacementFeatureSet", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->replacementFeatureSet);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->replacementFeatureSet);
+
+   invokeEndElement (pctxt, "replacementFeatureSet", -1);
+
+   /* decode neededFeatures */
+
+   if (pvalue->m.neededFeaturesPresent) {
+      invokeStartElement (pctxt, "neededFeatures", -1);
+
+      stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->neededFeatures);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "neededFeatures", -1);
+   }
+
+   /* decode desiredFeatures */
+
+   if (pvalue->m.desiredFeaturesPresent) {
+      invokeStartElement (pctxt, "desiredFeatures", -1);
+
+      stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->desiredFeatures);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "desiredFeatures", -1);
+   }
+
+   /* decode supportedFeatures */
+
+   if (pvalue->m.supportedFeaturesPresent) {
+      invokeStartElement (pctxt, "supportedFeatures", -1);
+
+      stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->supportedFeatures);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "supportedFeatures", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallProceeding_UUIE                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallProceeding_UUIE (OOCTXT* pctxt, H225CallProceeding_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h245AddressPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode destinationInfo */
+
+   invokeStartElement (pctxt, "destinationInfo", -1);
+
+   stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "destinationInfo", -1);
+
+   /* decode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      invokeStartElement (pctxt, "h245Address", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h245Address", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 9 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.h245SecurityModePresent = 1;
+
+                     invokeStartElement (pctxt, "h245SecurityMode", -1);
+
+                     stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h245SecurityMode", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.fastStartPresent = 1;
+
+                     invokeStartElement (pctxt, "fastStart", -1);
+
+                     stat = asn1PD_H225CallProceeding_UUIE_fastStart (pctxt, &pvalue->fastStart);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "fastStart", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.maintainConnectionPresent = 1;
+
+                     invokeStartElement (pctxt, "maintainConnection", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maintainConnection);
+
+                     invokeEndElement (pctxt, "maintainConnection", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.fastConnectRefusedPresent = 1;
+
+                     invokeStartElement (pctxt, "fastConnectRefused", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "fastConnectRefused", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE_fastStart                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Connect_UUIE_fastStart (OOCTXT* pctxt, H225Connect_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE_language                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Connect_UUIE_language (OOCTXT* pctxt, H225Connect_UUIE_language* pvalue)
+{
+   static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1IA5String);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      addSizeConstraint (pctxt, &element_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->elem[xx1], 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->elem[xx1]);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Connect_UUIE (OOCTXT* pctxt, H225Connect_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h245AddressPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      invokeStartElement (pctxt, "h245Address", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h245Address", -1);
+   }
+
+   /* decode destinationInfo */
+
+   invokeStartElement (pctxt, "destinationInfo", -1);
+
+   stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "destinationInfo", -1);
+
+   /* decode conferenceID */
+
+   invokeStartElement (pctxt, "conferenceID", -1);
+
+   stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceID", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 15 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.h245SecurityModePresent = 1;
+
+                     invokeStartElement (pctxt, "h245SecurityMode", -1);
+
+                     stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h245SecurityMode", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.fastStartPresent = 1;
+
+                     invokeStartElement (pctxt, "fastStart", -1);
+
+                     stat = asn1PD_H225Connect_UUIE_fastStart (pctxt, &pvalue->fastStart);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "fastStart", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.maintainConnectionPresent = 1;
+
+                     invokeStartElement (pctxt, "maintainConnection", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maintainConnection);
+
+                     invokeEndElement (pctxt, "maintainConnection", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.languagePresent = 1;
+
+                     invokeStartElement (pctxt, "language", -1);
+
+                     stat = asn1PD_H225Connect_UUIE_language (pctxt, &pvalue->language);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "language", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.connectedAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "connectedAddress", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->connectedAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "connectedAddress", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.presentationIndicatorPresent = 1;
+
+                     invokeStartElement (pctxt, "presentationIndicator", -1);
+
+                     stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "presentationIndicator", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.screeningIndicatorPresent = 1;
+
+                     invokeStartElement (pctxt, "screeningIndicator", -1);
+
+                     stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "screeningIndicator", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.fastConnectRefusedPresent = 1;
+
+                     invokeStartElement (pctxt, "fastConnectRefused", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "fastConnectRefused", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Alerting_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Alerting_UUIE_fastStart (OOCTXT* pctxt, H225Alerting_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Alerting_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Alerting_UUIE (OOCTXT* pctxt, H225Alerting_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h245AddressPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode destinationInfo */
+
+   invokeStartElement (pctxt, "destinationInfo", -1);
+
+   stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "destinationInfo", -1);
+
+   /* decode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      invokeStartElement (pctxt, "h245Address", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h245Address", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 14 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.h245SecurityModePresent = 1;
+
+                     invokeStartElement (pctxt, "h245SecurityMode", -1);
+
+                     stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h245SecurityMode", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.fastStartPresent = 1;
+
+                     invokeStartElement (pctxt, "fastStart", -1);
+
+                     stat = asn1PD_H225Alerting_UUIE_fastStart (pctxt, &pvalue->fastStart);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "fastStart", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.maintainConnectionPresent = 1;
+
+                     invokeStartElement (pctxt, "maintainConnection", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maintainConnection);
+
+                     invokeEndElement (pctxt, "maintainConnection", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.alertingAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "alertingAddress", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->alertingAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alertingAddress", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.presentationIndicatorPresent = 1;
+
+                     invokeStartElement (pctxt, "presentationIndicator", -1);
+
+                     stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "presentationIndicator", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.screeningIndicatorPresent = 1;
+
+                     invokeStartElement (pctxt, "screeningIndicator", -1);
+
+                     stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "screeningIndicator", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.fastConnectRefusedPresent = 1;
+
+                     invokeStartElement (pctxt, "fastConnectRefused", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "fastConnectRefused", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Information_UUIE_fastStart                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Information_UUIE_fastStart (OOCTXT* pctxt, H225Information_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Information_UUIE                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Information_UUIE (OOCTXT* pctxt, H225Information_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 6 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.fastStartPresent = 1;
+
+                     invokeStartElement (pctxt, "fastStart", -1);
+
+                     stat = asn1PD_H225Information_UUIE_fastStart (pctxt, &pvalue->fastStart);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "fastStart", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.fastConnectRefusedPresent = 1;
+
+                     invokeStartElement (pctxt, "fastConnectRefused", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "fastConnectRefused", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityErrors                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225SecurityErrors (OOCTXT* pctxt, H225SecurityErrors* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 15);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* securityWrongSyncTime */
+         case 0:
+            invokeStartElement (pctxt, "securityWrongSyncTime", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityWrongSyncTime", -1);
+
+            break;
+
+         /* securityReplay */
+         case 1:
+            invokeStartElement (pctxt, "securityReplay", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityReplay", -1);
+
+            break;
+
+         /* securityWrongGeneralID */
+         case 2:
+            invokeStartElement (pctxt, "securityWrongGeneralID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityWrongGeneralID", -1);
+
+            break;
+
+         /* securityWrongSendersID */
+         case 3:
+            invokeStartElement (pctxt, "securityWrongSendersID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityWrongSendersID", -1);
+
+            break;
+
+         /* securityIntegrityFailed */
+         case 4:
+            invokeStartElement (pctxt, "securityIntegrityFailed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityIntegrityFailed", -1);
+
+            break;
+
+         /* securityWrongOID */
+         case 5:
+            invokeStartElement (pctxt, "securityWrongOID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityWrongOID", -1);
+
+            break;
+
+         /* securityDHmismatch */
+         case 6:
+            invokeStartElement (pctxt, "securityDHmismatch", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDHmismatch", -1);
+
+            break;
+
+         /* securityCertificateExpired */
+         case 7:
+            invokeStartElement (pctxt, "securityCertificateExpired", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityCertificateExpired", -1);
+
+            break;
+
+         /* securityCertificateDateInvalid */
+         case 8:
+            invokeStartElement (pctxt, "securityCertificateDateInvalid", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityCertificateDateInvalid", -1);
+
+            break;
+
+         /* securityCertificateRevoked */
+         case 9:
+            invokeStartElement (pctxt, "securityCertificateRevoked", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityCertificateRevoked", -1);
+
+            break;
+
+         /* securityCertificateNotReadable */
+         case 10:
+            invokeStartElement (pctxt, "securityCertificateNotReadable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityCertificateNotReadable", -1);
+
+            break;
+
+         /* securityCertificateSignatureInvalid */
+         case 11:
+            invokeStartElement (pctxt, "securityCertificateSignatureInvalid", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityCertificateSignatureInvalid", -1);
+
+            break;
+
+         /* securityCertificateMissing */
+         case 12:
+            invokeStartElement (pctxt, "securityCertificateMissing", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityCertificateMissing", -1);
+
+            break;
+
+         /* securityCertificateIncomplete */
+         case 13:
+            invokeStartElement (pctxt, "securityCertificateIncomplete", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityCertificateIncomplete", -1);
+
+            break;
+
+         /* securityUnsupportedCertificateAlgOID */
+         case 14:
+            invokeStartElement (pctxt, "securityUnsupportedCertificateAlgOID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityUnsupportedCertificateAlgOID", -1);
+
+            break;
+
+         /* securityUnknownCA */
+         case 15:
+            invokeStartElement (pctxt, "securityUnknownCA", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityUnknownCA", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 17;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ReleaseCompleteReason                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ReleaseCompleteReason (OOCTXT* pctxt, H225ReleaseCompleteReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 11);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* noBandwidth */
+         case 0:
+            invokeStartElement (pctxt, "noBandwidth", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noBandwidth", -1);
+
+            break;
+
+         /* gatekeeperResources */
+         case 1:
+            invokeStartElement (pctxt, "gatekeeperResources", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "gatekeeperResources", -1);
+
+            break;
+
+         /* unreachableDestination */
+         case 2:
+            invokeStartElement (pctxt, "unreachableDestination", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unreachableDestination", -1);
+
+            break;
+
+         /* destinationRejection */
+         case 3:
+            invokeStartElement (pctxt, "destinationRejection", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "destinationRejection", -1);
+
+            break;
+
+         /* invalidRevision */
+         case 4:
+            invokeStartElement (pctxt, "invalidRevision", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidRevision", -1);
+
+            break;
+
+         /* noPermission */
+         case 5:
+            invokeStartElement (pctxt, "noPermission", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noPermission", -1);
+
+            break;
+
+         /* unreachableGatekeeper */
+         case 6:
+            invokeStartElement (pctxt, "unreachableGatekeeper", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unreachableGatekeeper", -1);
+
+            break;
+
+         /* gatewayResources */
+         case 7:
+            invokeStartElement (pctxt, "gatewayResources", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "gatewayResources", -1);
+
+            break;
+
+         /* badFormatAddress */
+         case 8:
+            invokeStartElement (pctxt, "badFormatAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "badFormatAddress", -1);
+
+            break;
+
+         /* adaptiveBusy */
+         case 9:
+            invokeStartElement (pctxt, "adaptiveBusy", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "adaptiveBusy", -1);
+
+            break;
+
+         /* inConf */
+         case 10:
+            invokeStartElement (pctxt, "inConf", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "inConf", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 11:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 13;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* facilityCallDeflection */
+         case 13:
+            invokeStartElement (pctxt, "facilityCallDeflection", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "facilityCallDeflection", -1);
+
+            break;
+
+         /* securityDenied */
+         case 14:
+            invokeStartElement (pctxt, "securityDenied", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenied", -1);
+
+            break;
+
+         /* calledPartyNotRegistered */
+         case 15:
+            invokeStartElement (pctxt, "calledPartyNotRegistered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "calledPartyNotRegistered", -1);
+
+            break;
+
+         /* callerNotRegistered */
+         case 16:
+            invokeStartElement (pctxt, "callerNotRegistered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "callerNotRegistered", -1);
+
+            break;
+
+         /* newConnectionNeeded */
+         case 17:
+            invokeStartElement (pctxt, "newConnectionNeeded", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "newConnectionNeeded", -1);
+
+            break;
+
+         /* nonStandardReason */
+         case 18:
+            invokeStartElement (pctxt, "nonStandardReason", -1);
+
+            pvalue->u.nonStandardReason = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
+
+            stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandardReason);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandardReason", -1);
+
+            break;
+
+         /* replaceWithConferenceInvite */
+         case 19:
+            invokeStartElement (pctxt, "replaceWithConferenceInvite", -1);
+
+            pvalue->u.replaceWithConferenceInvite = ALLOC_ASN1ELEM (pctxt, H225ConferenceIdentifier);
+
+            stat = asn1PD_H225ConferenceIdentifier (pctxt, pvalue->u.replaceWithConferenceInvite);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "replaceWithConferenceInvite", -1);
+
+            break;
+
+         /* genericDataReason */
+         case 20:
+            invokeStartElement (pctxt, "genericDataReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "genericDataReason", -1);
+
+            break;
+
+         /* neededFeatureNotSupported */
+         case 21:
+            invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
+
+            break;
+
+         /* tunnelledSignallingRejected */
+         case 22:
+            invokeStartElement (pctxt, "tunnelledSignallingRejected", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "tunnelledSignallingRejected", -1);
+
+            break;
+
+         /* invalidCID */
+         case 23:
+            invokeStartElement (pctxt, "invalidCID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidCID", -1);
+
+            break;
+
+         /* securityError */
+         case 24:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors);
+
+            stat = asn1PD_H225SecurityErrors (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         /* hopCountExceeded */
+         case 25:
+            invokeStartElement (pctxt, "hopCountExceeded", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hopCountExceeded", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ReleaseComplete_UUIE                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ReleaseComplete_UUIE (OOCTXT* pctxt, H225ReleaseComplete_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.reasonPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode reason */
+
+   if (pvalue->m.reasonPresent) {
+      invokeStartElement (pctxt, "reason", -1);
+
+      stat = asn1PD_H225ReleaseCompleteReason (pctxt, &pvalue->reason);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "reason", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 9 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.busyAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "busyAddress", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->busyAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "busyAddress", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.presentationIndicatorPresent = 1;
+
+                     invokeStartElement (pctxt, "presentationIndicator", -1);
+
+                     stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "presentationIndicator", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.screeningIndicatorPresent = 1;
+
+                     invokeStartElement (pctxt, "screeningIndicator", -1);
+
+                     stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "screeningIndicator", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FacilityReason                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225FacilityReason (OOCTXT* pctxt, H225FacilityReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* routeCallToGatekeeper */
+         case 0:
+            invokeStartElement (pctxt, "routeCallToGatekeeper", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "routeCallToGatekeeper", -1);
+
+            break;
+
+         /* callForwarded */
+         case 1:
+            invokeStartElement (pctxt, "callForwarded", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "callForwarded", -1);
+
+            break;
+
+         /* routeCallToMC */
+         case 2:
+            invokeStartElement (pctxt, "routeCallToMC", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "routeCallToMC", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 3:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* conferenceListChoice */
+         case 5:
+            invokeStartElement (pctxt, "conferenceListChoice", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "conferenceListChoice", -1);
+
+            break;
+
+         /* startH245 */
+         case 6:
+            invokeStartElement (pctxt, "startH245", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "startH245", -1);
+
+            break;
+
+         /* noH245 */
+         case 7:
+            invokeStartElement (pctxt, "noH245", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noH245", -1);
+
+            break;
+
+         /* newTokens */
+         case 8:
+            invokeStartElement (pctxt, "newTokens", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "newTokens", -1);
+
+            break;
+
+         /* featureSetUpdate */
+         case 9:
+            invokeStartElement (pctxt, "featureSetUpdate", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "featureSetUpdate", -1);
+
+            break;
+
+         /* forwardedElements */
+         case 10:
+            invokeStartElement (pctxt, "forwardedElements", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "forwardedElements", -1);
+
+            break;
+
+         /* transportedInformation */
+         case 11:
+            invokeStartElement (pctxt, "transportedInformation", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transportedInformation", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceList                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ConferenceList (OOCTXT* pctxt, H225ConferenceList* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.conferenceIDPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.conferenceAliasPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode conferenceID */
+
+   if (pvalue->m.conferenceIDPresent) {
+      invokeStartElement (pctxt, "conferenceID", -1);
+
+      stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "conferenceID", -1);
+   }
+
+   /* decode conferenceAlias */
+
+   if (pvalue->m.conferenceAliasPresent) {
+      invokeStartElement (pctxt, "conferenceAlias", -1);
+
+      stat = asn1PD_H225AliasAddress (pctxt, &pvalue->conferenceAlias);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "conferenceAlias", -1);
+   }
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ConferenceList                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225ConferenceList (OOCTXT* pctxt, H225_SeqOfH225ConferenceList* pvalue)
+{
+   int stat = ASN_OK;
+   H225ConferenceList* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225ConferenceList);
+
+         stat = asn1PD_H225ConferenceList (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Facility_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Facility_UUIE_fastStart (OOCTXT* pctxt, H225Facility_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Facility_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Facility_UUIE (OOCTXT* pctxt, H225Facility_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.alternativeAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.alternativeAliasAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.conferenceIDPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode alternativeAddress */
+
+   if (pvalue->m.alternativeAddressPresent) {
+      invokeStartElement (pctxt, "alternativeAddress", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->alternativeAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "alternativeAddress", -1);
+   }
+
+   /* decode alternativeAliasAddress */
+
+   if (pvalue->m.alternativeAliasAddressPresent) {
+      invokeStartElement (pctxt, "alternativeAliasAddress", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->alternativeAliasAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "alternativeAliasAddress", -1);
+   }
+
+   /* decode conferenceID */
+
+   if (pvalue->m.conferenceIDPresent) {
+      invokeStartElement (pctxt, "conferenceID", -1);
+
+      stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "conferenceID", -1);
+   }
+
+   /* decode reason */
+
+   invokeStartElement (pctxt, "reason", -1);
+
+   stat = asn1PD_H225FacilityReason (pctxt, &pvalue->reason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "reason", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 16 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.destExtraCallInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "destExtraCallInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destExtraCallInfo", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.remoteExtensionAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "remoteExtensionAddress", -1);
+
+                     stat = asn1PD_H225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "remoteExtensionAddress", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.conferencesPresent = 1;
+
+                     invokeStartElement (pctxt, "conferences", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ConferenceList (pctxt, &pvalue->conferences);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "conferences", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.h245AddressPresent = 1;
+
+                     invokeStartElement (pctxt, "h245Address", -1);
+
+                     stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h245Address", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.fastStartPresent = 1;
+
+                     invokeStartElement (pctxt, "fastStart", -1);
+
+                     stat = asn1PD_H225Facility_UUIE_fastStart (pctxt, &pvalue->fastStart);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "fastStart", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.maintainConnectionPresent = 1;
+
+                     invokeStartElement (pctxt, "maintainConnection", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maintainConnection);
+
+                     invokeEndElement (pctxt, "maintainConnection", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.fastConnectRefusedPresent = 1;
+
+                     invokeStartElement (pctxt, "fastConnectRefused", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "fastConnectRefused", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.destinationInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "destinationInfo", -1);
+
+                     stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destinationInfo", -1);
+                     break;
+
+                  case 15:
+                     pvalue->m.h245SecurityModePresent = 1;
+
+                     invokeStartElement (pctxt, "h245SecurityMode", -1);
+
+                     stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h245SecurityMode", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Progress_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Progress_UUIE_fastStart (OOCTXT* pctxt, H225Progress_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Progress_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Progress_UUIE (OOCTXT* pctxt, H225Progress_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h245AddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h245SecurityModePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.fastStartPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode destinationInfo */
+
+   invokeStartElement (pctxt, "destinationInfo", -1);
+
+   stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "destinationInfo", -1);
+
+   /* decode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      invokeStartElement (pctxt, "h245Address", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h245Address", -1);
+   }
+
+   /* decode callIdentifier */
+
+   invokeStartElement (pctxt, "callIdentifier", -1);
+
+   stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callIdentifier", -1);
+
+   /* decode h245SecurityMode */
+
+   if (pvalue->m.h245SecurityModePresent) {
+      invokeStartElement (pctxt, "h245SecurityMode", -1);
+
+      stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h245SecurityMode", -1);
+   }
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode fastStart */
+
+   if (pvalue->m.fastStartPresent) {
+      invokeStartElement (pctxt, "fastStart", -1);
+
+      stat = asn1PD_H225Progress_UUIE_fastStart (pctxt, &pvalue->fastStart);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "fastStart", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 3 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.maintainConnectionPresent = 1;
+
+                     invokeStartElement (pctxt, "maintainConnection", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maintainConnection);
+
+                     invokeEndElement (pctxt, "maintainConnection", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.fastConnectRefusedPresent = 1;
+
+                     invokeStartElement (pctxt, "fastConnectRefused", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "fastConnectRefused", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Status_UUIE                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Status_UUIE (OOCTXT* pctxt, H225Status_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode callIdentifier */
+
+   invokeStartElement (pctxt, "callIdentifier", -1);
+
+   stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callIdentifier", -1);
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  StatusInquiry_UUIE                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225StatusInquiry_UUIE (OOCTXT* pctxt, H225StatusInquiry_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode callIdentifier */
+
+   invokeStartElement (pctxt, "callIdentifier", -1);
+
+   stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callIdentifier", -1);
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SetupAcknowledge_UUIE                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225SetupAcknowledge_UUIE (OOCTXT* pctxt, H225SetupAcknowledge_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode callIdentifier */
+
+   invokeStartElement (pctxt, "callIdentifier", -1);
+
+   stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callIdentifier", -1);
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Notify_UUIE                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Notify_UUIE (OOCTXT* pctxt, H225Notify_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode callIdentifier */
+
+   invokeStartElement (pctxt, "callIdentifier", -1);
+
+   stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callIdentifier", -1);
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h323_message_body                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UU_PDU_h323_message_body (OOCTXT* pctxt, H225H323_UU_PDU_h323_message_body* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* setup */
+         case 0:
+            invokeStartElement (pctxt, "setup", -1);
+
+            pvalue->u.setup = ALLOC_ASN1ELEM (pctxt, H225Setup_UUIE);
+
+            stat = asn1PD_H225Setup_UUIE (pctxt, pvalue->u.setup);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "setup", -1);
+
+            break;
+
+         /* callProceeding */
+         case 1:
+            invokeStartElement (pctxt, "callProceeding", -1);
+
+            pvalue->u.callProceeding = ALLOC_ASN1ELEM (pctxt, H225CallProceeding_UUIE);
+
+            stat = asn1PD_H225CallProceeding_UUIE (pctxt, pvalue->u.callProceeding);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "callProceeding", -1);
+
+            break;
+
+         /* connect */
+         case 2:
+            invokeStartElement (pctxt, "connect", -1);
+
+            pvalue->u.connect = ALLOC_ASN1ELEM (pctxt, H225Connect_UUIE);
+
+            stat = asn1PD_H225Connect_UUIE (pctxt, pvalue->u.connect);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "connect", -1);
+
+            break;
+
+         /* alerting */
+         case 3:
+            invokeStartElement (pctxt, "alerting", -1);
+
+            pvalue->u.alerting = ALLOC_ASN1ELEM (pctxt, H225Alerting_UUIE);
+
+            stat = asn1PD_H225Alerting_UUIE (pctxt, pvalue->u.alerting);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "alerting", -1);
+
+            break;
+
+         /* information */
+         case 4:
+            invokeStartElement (pctxt, "information", -1);
+
+            pvalue->u.information = ALLOC_ASN1ELEM (pctxt, H225Information_UUIE);
+
+            stat = asn1PD_H225Information_UUIE (pctxt, pvalue->u.information);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "information", -1);
+
+            break;
+
+         /* releaseComplete */
+         case 5:
+            invokeStartElement (pctxt, "releaseComplete", -1);
+
+            pvalue->u.releaseComplete = ALLOC_ASN1ELEM (pctxt, H225ReleaseComplete_UUIE);
+
+            stat = asn1PD_H225ReleaseComplete_UUIE (pctxt, pvalue->u.releaseComplete);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "releaseComplete", -1);
+
+            break;
+
+         /* facility */
+         case 6:
+            invokeStartElement (pctxt, "facility", -1);
+
+            pvalue->u.facility = ALLOC_ASN1ELEM (pctxt, H225Facility_UUIE);
+
+            stat = asn1PD_H225Facility_UUIE (pctxt, pvalue->u.facility);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "facility", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 8;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* progress */
+         case 8:
+            invokeStartElement (pctxt, "progress", -1);
+
+            pvalue->u.progress = ALLOC_ASN1ELEM (pctxt, H225Progress_UUIE);
+
+            stat = asn1PD_H225Progress_UUIE (pctxt, pvalue->u.progress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "progress", -1);
+
+            break;
+
+         /* empty */
+         case 9:
+            invokeStartElement (pctxt, "empty", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "empty", -1);
+
+            break;
+
+         /* status */
+         case 10:
+            invokeStartElement (pctxt, "status", -1);
+
+            pvalue->u.status = ALLOC_ASN1ELEM (pctxt, H225Status_UUIE);
+
+            stat = asn1PD_H225Status_UUIE (pctxt, pvalue->u.status);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "status", -1);
+
+            break;
+
+         /* statusInquiry */
+         case 11:
+            invokeStartElement (pctxt, "statusInquiry", -1);
+
+            pvalue->u.statusInquiry = ALLOC_ASN1ELEM (pctxt, H225StatusInquiry_UUIE);
+
+            stat = asn1PD_H225StatusInquiry_UUIE (pctxt, pvalue->u.statusInquiry);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "statusInquiry", -1);
+
+            break;
+
+         /* setupAcknowledge */
+         case 12:
+            invokeStartElement (pctxt, "setupAcknowledge", -1);
+
+            pvalue->u.setupAcknowledge = ALLOC_ASN1ELEM (pctxt, H225SetupAcknowledge_UUIE);
+
+            stat = asn1PD_H225SetupAcknowledge_UUIE (pctxt, pvalue->u.setupAcknowledge);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "setupAcknowledge", -1);
+
+            break;
+
+         /* notify */
+         case 13:
+            invokeStartElement (pctxt, "notify", -1);
+
+            pvalue->u.notify = ALLOC_ASN1ELEM (pctxt, H225Notify_UUIE);
+
+            stat = asn1PD_H225Notify_UUIE (pctxt, pvalue->u.notify);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "notify", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h4501SupplementaryService                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UU_PDU_h4501SupplementaryService (OOCTXT* pctxt, H225H323_UU_PDU_h4501SupplementaryService* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h245Control                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UU_PDU_h245Control (OOCTXT* pctxt, H225H323_UU_PDU_h245Control* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225NonStandardParameter                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225NonStandardParameter (OOCTXT* pctxt, H225_SeqOfH225NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+   H225NonStandardParameter* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225NonStandardParameter);
+
+         stat = asn1PD_H225NonStandardParameter (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallLinkage                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallLinkage (OOCTXT* pctxt, H225CallLinkage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.globalCallIdPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.threadIdPresent = optbit;
+
+   /* decode globalCallId */
+
+   if (pvalue->m.globalCallIdPresent) {
+      invokeStartElement (pctxt, "globalCallId", -1);
+
+      stat = asn1PD_H225GloballyUniqueID (pctxt, &pvalue->globalCallId);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "globalCallId", -1);
+   }
+
+   /* decode threadId */
+
+   if (pvalue->m.threadIdPresent) {
+      invokeStartElement (pctxt, "threadId", -1);
+
+      stat = asn1PD_H225GloballyUniqueID (pctxt, &pvalue->threadId);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "threadId", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_tunnelledSignallingMessage_messageContent     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage_messageContent* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_tunnelledSignallingMessage                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tunnellingRequiredPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode tunnelledProtocolID */
+
+   invokeStartElement (pctxt, "tunnelledProtocolID", -1);
+
+   stat = asn1PD_H225TunnelledProtocol (pctxt, &pvalue->tunnelledProtocolID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "tunnelledProtocolID", -1);
+
+   /* decode messageContent */
+
+   invokeStartElement (pctxt, "messageContent", -1);
+
+   stat = asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (pctxt, &pvalue->messageContent);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "messageContent", -1);
+
+   /* decode tunnellingRequired */
+
+   if (pvalue->m.tunnellingRequiredPresent) {
+      invokeStartElement (pctxt, "tunnellingRequired", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "tunnellingRequired", -1);
+   }
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  StimulusControl                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225StimulusControl (OOCTXT* pctxt, H225StimulusControl* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.isTextPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h248MessagePresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   /* decode isText */
+
+   if (pvalue->m.isTextPresent) {
+      invokeStartElement (pctxt, "isText", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "isText", -1);
+   }
+
+   /* decode h248Message */
+
+   if (pvalue->m.h248MessagePresent) {
+      invokeStartElement (pctxt, "h248Message", -1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->h248Message);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->h248Message.numocts, pvalue->h248Message.data);
+
+      invokeEndElement (pctxt, "h248Message", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UU_PDU (OOCTXT* pctxt, H225H323_UU_PDU* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode h323_message_body */
+
+   invokeStartElement (pctxt, "h323_message_body", -1);
+
+   stat = asn1PD_H225H323_UU_PDU_h323_message_body (pctxt, &pvalue->h323_message_body);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "h323_message_body", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 9 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.h4501SupplementaryServicePresent = 1;
+
+                     invokeStartElement (pctxt, "h4501SupplementaryService", -1);
+
+                     stat = asn1PD_H225H323_UU_PDU_h4501SupplementaryService (pctxt, &pvalue->h4501SupplementaryService);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h4501SupplementaryService", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.h245TunnelingPresent = 1;
+
+                     invokeStartElement (pctxt, "h245Tunneling", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->h245Tunneling);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->h245Tunneling);
+
+                     invokeEndElement (pctxt, "h245Tunneling", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.h245ControlPresent = 1;
+
+                     invokeStartElement (pctxt, "h245Control", -1);
+
+                     stat = asn1PD_H225H323_UU_PDU_h245Control (pctxt, &pvalue->h245Control);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h245Control", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.nonStandardControlPresent = 1;
+
+                     invokeStartElement (pctxt, "nonStandardControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "nonStandardControl", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.callLinkagePresent = 1;
+
+                     invokeStartElement (pctxt, "callLinkage", -1);
+
+                     stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callLinkage", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.tunnelledSignallingMessagePresent = 1;
+
+                     invokeStartElement (pctxt, "tunnelledSignallingMessage", -1);
+
+                     stat = asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage (pctxt, &pvalue->tunnelledSignallingMessage);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tunnelledSignallingMessage", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.provisionalRespToH245TunnelingPresent = 1;
+
+                     invokeStartElement (pctxt, "provisionalRespToH245Tunneling", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "provisionalRespToH245Tunneling", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.stimulusControlPresent = 1;
+
+                     invokeStartElement (pctxt, "stimulusControl", -1);
+
+                     stat = asn1PD_H225StimulusControl (pctxt, &pvalue->stimulusControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "stimulusControl", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation_user_data                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UserInformation_user_data (OOCTXT* pctxt, H225H323_UserInformation_user_data* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode protocol_discriminator */
+
+   invokeStartElement (pctxt, "protocol_discriminator", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->protocol_discriminator, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->protocol_discriminator);
+
+   invokeEndElement (pctxt, "protocol_discriminator", -1);
+
+   /* decode user_information */
+
+   invokeStartElement (pctxt, "user_information", -1);
+
+   stat = asn1PD_H225H323_UserInformation_user_data_user_information (pctxt, &pvalue->user_information);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "user_information", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225H323_UserInformation (OOCTXT* pctxt, H225H323_UserInformation* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.user_dataPresent = optbit;
+
+   /* decode h323_uu_pdu */
+
+   invokeStartElement (pctxt, "h323_uu_pdu", -1);
+
+   stat = asn1PD_H225H323_UU_PDU (pctxt, &pvalue->h323_uu_pdu);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "h323_uu_pdu", -1);
+
+   /* decode user_data */
+
+   if (pvalue->m.user_dataPresent) {
+      invokeStartElement (pctxt, "user_data", -1);
+
+      stat = asn1PD_H225H323_UserInformation_user_data (pctxt, &pvalue->user_data);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "user_data", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AddressPattern_range                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AddressPattern_range (OOCTXT* pctxt, H225AddressPattern_range* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode startOfRange */
+
+   invokeStartElement (pctxt, "startOfRange", -1);
+
+   stat = asn1PD_H225PartyNumber (pctxt, &pvalue->startOfRange);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "startOfRange", -1);
+
+   /* decode endOfRange */
+
+   invokeStartElement (pctxt, "endOfRange", -1);
+
+   stat = asn1PD_H225PartyNumber (pctxt, &pvalue->endOfRange);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endOfRange", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AddressPattern                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AddressPattern (OOCTXT* pctxt, H225AddressPattern* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* wildcard */
+         case 0:
+            invokeStartElement (pctxt, "wildcard", -1);
+
+            pvalue->u.wildcard = ALLOC_ASN1ELEM (pctxt, H225AliasAddress);
+
+            stat = asn1PD_H225AliasAddress (pctxt, pvalue->u.wildcard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "wildcard", -1);
+
+            break;
+
+         /* range */
+         case 1:
+            invokeStartElement (pctxt, "range", -1);
+
+            pvalue->u.range = ALLOC_ASN1ELEM (pctxt, H225AddressPattern_range);
+
+            stat = asn1PD_H225AddressPattern_range (pctxt, pvalue->u.range);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "range", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportAddress                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225TransportAddress (OOCTXT* pctxt, H225_SeqOfH225TransportAddress* pvalue)
+{
+   int stat = ASN_OK;
+   H225TransportAddress* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225TransportAddress);
+
+         stat = asn1PD_H225TransportAddress (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AlternateTransportAddresses                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AlternateTransportAddresses (OOCTXT* pctxt, H225AlternateTransportAddresses* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.annexEPresent = optbit;
+
+   /* decode annexE */
+
+   if (pvalue->m.annexEPresent) {
+      invokeStartElement (pctxt, "annexE", -1);
+
+      stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->annexE);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "annexE", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.sctpPresent = 1;
+
+                     invokeStartElement (pctxt, "sctp", -1);
+
+                     stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->sctp);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "sctp", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Endpoint                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225Endpoint (OOCTXT* pctxt, H225Endpoint* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.aliasAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callSignalAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.rasAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endpointTypePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.priorityPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.remoteExtensionAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destExtraCallInfoPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode aliasAddress */
+
+   if (pvalue->m.aliasAddressPresent) {
+      invokeStartElement (pctxt, "aliasAddress", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->aliasAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "aliasAddress", -1);
+   }
+
+   /* decode callSignalAddress */
+
+   if (pvalue->m.callSignalAddressPresent) {
+      invokeStartElement (pctxt, "callSignalAddress", -1);
+
+      stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callSignalAddress", -1);
+   }
+
+   /* decode rasAddress */
+
+   if (pvalue->m.rasAddressPresent) {
+      invokeStartElement (pctxt, "rasAddress", -1);
+
+      stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->rasAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "rasAddress", -1);
+   }
+
+   /* decode endpointType */
+
+   if (pvalue->m.endpointTypePresent) {
+      invokeStartElement (pctxt, "endpointType", -1);
+
+      stat = asn1PD_H225EndpointType (pctxt, &pvalue->endpointType);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "endpointType", -1);
+   }
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode priority */
+
+   if (pvalue->m.priorityPresent) {
+      invokeStartElement (pctxt, "priority", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->priority, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->priority);
+
+      invokeEndElement (pctxt, "priority", -1);
+   }
+
+   /* decode remoteExtensionAddress */
+
+   if (pvalue->m.remoteExtensionAddressPresent) {
+      invokeStartElement (pctxt, "remoteExtensionAddress", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "remoteExtensionAddress", -1);
+   }
+
+   /* decode destExtraCallInfo */
+
+   if (pvalue->m.destExtraCallInfoPresent) {
+      invokeStartElement (pctxt, "destExtraCallInfo", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destExtraCallInfo", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 3 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.alternateTransportAddressesPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateTransportAddresses", -1);
+
+                     stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateTransportAddresses", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UseSpecifiedTransport                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225UseSpecifiedTransport (OOCTXT* pctxt, H225UseSpecifiedTransport* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* tcp */
+         case 0:
+            invokeStartElement (pctxt, "tcp", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "tcp", -1);
+
+            break;
+
+         /* annexE */
+         case 1:
+            invokeStartElement (pctxt, "annexE", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "annexE", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* sctp */
+         case 3:
+            invokeStartElement (pctxt, "sctp", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "sctp", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AlternateGK                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AlternateGK (OOCTXT* pctxt, H225AlternateGK* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatekeeperIdentifierPresent = optbit;
+
+   /* decode rasAddress */
+
+   invokeStartElement (pctxt, "rasAddress", -1);
+
+   stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rasAddress", -1);
+
+   /* decode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+      stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+   }
+
+   /* decode needToRegister */
+
+   invokeStartElement (pctxt, "needToRegister", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->needToRegister);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->needToRegister);
+
+   invokeEndElement (pctxt, "needToRegister", -1);
+
+   /* decode priority */
+
+   invokeStartElement (pctxt, "priority", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->priority, 0U, 127U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->priority);
+
+   invokeEndElement (pctxt, "priority", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AlternateGK                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225AlternateGK (OOCTXT* pctxt, H225_SeqOfH225AlternateGK* pvalue)
+{
+   int stat = ASN_OK;
+   H225AlternateGK* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AlternateGK);
+
+         stat = asn1PD_H225AlternateGK (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AltGKInfo                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AltGKInfo (OOCTXT* pctxt, H225AltGKInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode alternateGatekeeper */
+
+   invokeStartElement (pctxt, "alternateGatekeeper", -1);
+
+   stat = asn1PD_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "alternateGatekeeper", -1);
+
+   /* decode altGKisPermanent */
+
+   invokeStartElement (pctxt, "altGKisPermanent", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->altGKisPermanent);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->altGKisPermanent);
+
+   invokeEndElement (pctxt, "altGKisPermanent", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityErrors2                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225SecurityErrors2 (OOCTXT* pctxt, H225SecurityErrors2* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* securityWrongSyncTime */
+         case 0:
+            invokeStartElement (pctxt, "securityWrongSyncTime", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityWrongSyncTime", -1);
+
+            break;
+
+         /* securityReplay */
+         case 1:
+            invokeStartElement (pctxt, "securityReplay", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityReplay", -1);
+
+            break;
+
+         /* securityWrongGeneralID */
+         case 2:
+            invokeStartElement (pctxt, "securityWrongGeneralID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityWrongGeneralID", -1);
+
+            break;
+
+         /* securityWrongSendersID */
+         case 3:
+            invokeStartElement (pctxt, "securityWrongSendersID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityWrongSendersID", -1);
+
+            break;
+
+         /* securityIntegrityFailed */
+         case 4:
+            invokeStartElement (pctxt, "securityIntegrityFailed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityIntegrityFailed", -1);
+
+            break;
+
+         /* securityWrongOID */
+         case 5:
+            invokeStartElement (pctxt, "securityWrongOID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityWrongOID", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptIntAlg                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225EncryptIntAlg (OOCTXT* pctxt, H225EncryptIntAlg* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
+
+            stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* isoAlgorithm */
+         case 1:
+            invokeStartElement (pctxt, "isoAlgorithm", -1);
+
+            pvalue->u.isoAlgorithm = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.isoAlgorithm);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.isoAlgorithm->numids, pvalue->u.isoAlgorithm->subid);
+
+            invokeEndElement (pctxt, "isoAlgorithm", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonIsoIntegrityMechanism                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225NonIsoIntegrityMechanism (OOCTXT* pctxt, H225NonIsoIntegrityMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* hMAC_MD5 */
+         case 0:
+            invokeStartElement (pctxt, "hMAC_MD5", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hMAC_MD5", -1);
+
+            break;
+
+         /* hMAC_iso10118_2_s */
+         case 1:
+            invokeStartElement (pctxt, "hMAC_iso10118_2_s", -1);
+
+            pvalue->u.hMAC_iso10118_2_s = ALLOC_ASN1ELEM (pctxt, H225EncryptIntAlg);
+
+            stat = asn1PD_H225EncryptIntAlg (pctxt, pvalue->u.hMAC_iso10118_2_s);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "hMAC_iso10118_2_s", -1);
+
+            break;
+
+         /* hMAC_iso10118_2_l */
+         case 2:
+            invokeStartElement (pctxt, "hMAC_iso10118_2_l", -1);
+
+            pvalue->u.hMAC_iso10118_2_l = ALLOC_ASN1ELEM (pctxt, H225EncryptIntAlg);
+
+            stat = asn1PD_H225EncryptIntAlg (pctxt, pvalue->u.hMAC_iso10118_2_l);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "hMAC_iso10118_2_l", -1);
+
+            break;
+
+         /* hMAC_iso10118_3 */
+         case 3:
+            invokeStartElement (pctxt, "hMAC_iso10118_3", -1);
+
+            pvalue->u.hMAC_iso10118_3 = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.hMAC_iso10118_3);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.hMAC_iso10118_3->numids, pvalue->u.hMAC_iso10118_3->subid);
+
+            invokeEndElement (pctxt, "hMAC_iso10118_3", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IntegrityMechanism                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225IntegrityMechanism (OOCTXT* pctxt, H225IntegrityMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
+
+            stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* digSig */
+         case 1:
+            invokeStartElement (pctxt, "digSig", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "digSig", -1);
+
+            break;
+
+         /* iso9797 */
+         case 2:
+            invokeStartElement (pctxt, "iso9797", -1);
+
+            pvalue->u.iso9797 = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.iso9797);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.iso9797->numids, pvalue->u.iso9797->subid);
+
+            invokeEndElement (pctxt, "iso9797", -1);
+
+            break;
+
+         /* nonIsoIM */
+         case 3:
+            invokeStartElement (pctxt, "nonIsoIM", -1);
+
+            pvalue->u.nonIsoIM = ALLOC_ASN1ELEM (pctxt, H225NonIsoIntegrityMechanism);
+
+            stat = asn1PD_H225NonIsoIntegrityMechanism (pctxt, pvalue->u.nonIsoIM);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonIsoIM", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ICV                                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ICV (OOCTXT* pctxt, H225ICV* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode algorithmOID */
+
+   invokeStartElement (pctxt, "algorithmOID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
+
+   invokeEndElement (pctxt, "algorithmOID", -1);
+
+   /* decode icv */
+
+   invokeStartElement (pctxt, "icv", -1);
+
+   stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->icv);
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->icv.numbits, pvalue->icv.data);
+
+   invokeEndElement (pctxt, "icv", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingCapability                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CapacityReportingCapability (OOCTXT* pctxt, H225CapacityReportingCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode canReportCallCapacity */
+
+   invokeStartElement (pctxt, "canReportCallCapacity", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->canReportCallCapacity);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->canReportCallCapacity);
+
+   invokeEndElement (pctxt, "canReportCallCapacity", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingSpecification_when                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CapacityReportingSpecification_when (OOCTXT* pctxt, H225CapacityReportingSpecification_when* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callStartPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callEndPresent = optbit;
+
+   /* decode callStart */
+
+   if (pvalue->m.callStartPresent) {
+      invokeStartElement (pctxt, "callStart", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "callStart", -1);
+   }
+
+   /* decode callEnd */
+
+   if (pvalue->m.callEndPresent) {
+      invokeStartElement (pctxt, "callEnd", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "callEnd", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingSpecification                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CapacityReportingSpecification (OOCTXT* pctxt, H225CapacityReportingSpecification* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode when */
+
+   invokeStartElement (pctxt, "when", -1);
+
+   stat = asn1PD_H225CapacityReportingSpecification_when (pctxt, &pvalue->when);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "when", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageInfoTypes                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RasUsageInfoTypes (OOCTXT* pctxt, H225RasUsageInfoTypes* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.startTimePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endTimePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminationCausePresent = optbit;
+
+   /* decode nonStandardUsageTypes */
+
+   invokeStartElement (pctxt, "nonStandardUsageTypes", -1);
+
+   stat = asn1PD_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardUsageTypes);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nonStandardUsageTypes", -1);
+
+   /* decode startTime */
+
+   if (pvalue->m.startTimePresent) {
+      invokeStartElement (pctxt, "startTime", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "startTime", -1);
+   }
+
+   /* decode endTime */
+
+   if (pvalue->m.endTimePresent) {
+      invokeStartElement (pctxt, "endTime", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "endTime", -1);
+   }
+
+   /* decode terminationCause */
+
+   if (pvalue->m.terminationCausePresent) {
+      invokeStartElement (pctxt, "terminationCause", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "terminationCause", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification_when                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RasUsageSpecification_when (OOCTXT* pctxt, H225RasUsageSpecification_when* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.startPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.inIrrPresent = optbit;
+
+   /* decode start */
+
+   if (pvalue->m.startPresent) {
+      invokeStartElement (pctxt, "start", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "start", -1);
+   }
+
+   /* decode end */
+
+   if (pvalue->m.endPresent) {
+      invokeStartElement (pctxt, "end", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "end", -1);
+   }
+
+   /* decode inIrr */
+
+   if (pvalue->m.inIrrPresent) {
+      invokeStartElement (pctxt, "inIrr", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "inIrr", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification_callStartingPoint                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RasUsageSpecification_callStartingPoint (OOCTXT* pctxt, H225RasUsageSpecification_callStartingPoint* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.alertingPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.connectPresent = optbit;
+
+   /* decode alerting */
+
+   if (pvalue->m.alertingPresent) {
+      invokeStartElement (pctxt, "alerting", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "alerting", -1);
+   }
+
+   /* decode connect */
+
+   if (pvalue->m.connectPresent) {
+      invokeStartElement (pctxt, "connect", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "connect", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RasUsageSpecification (OOCTXT* pctxt, H225RasUsageSpecification* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callStartingPointPresent = optbit;
+
+   /* decode when */
+
+   invokeStartElement (pctxt, "when", -1);
+
+   stat = asn1PD_H225RasUsageSpecification_when (pctxt, &pvalue->when);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "when", -1);
+
+   /* decode callStartingPoint */
+
+   if (pvalue->m.callStartingPointPresent) {
+      invokeStartElement (pctxt, "callStartingPoint", -1);
+
+      stat = asn1PD_H225RasUsageSpecification_callStartingPoint (pctxt, &pvalue->callStartingPoint);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callStartingPoint", -1);
+   }
+
+   /* decode required */
+
+   invokeStartElement (pctxt, "required", -1);
+
+   stat = asn1PD_H225RasUsageInfoTypes (pctxt, &pvalue->required);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "required", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageInformation                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RasUsageInformation (OOCTXT* pctxt, H225RasUsageInformation* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.alertingTimePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.connectTimePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endTimePresent = optbit;
+
+   /* decode nonStandardUsageFields */
+
+   invokeStartElement (pctxt, "nonStandardUsageFields", -1);
+
+   stat = asn1PD_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardUsageFields);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nonStandardUsageFields", -1);
+
+   /* decode alertingTime */
+
+   if (pvalue->m.alertingTimePresent) {
+      invokeStartElement (pctxt, "alertingTime", -1);
+
+      stat = asn1PD_H235TimeStamp (pctxt, &pvalue->alertingTime);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "alertingTime", -1);
+   }
+
+   /* decode connectTime */
+
+   if (pvalue->m.connectTimePresent) {
+      invokeStartElement (pctxt, "connectTime", -1);
+
+      stat = asn1PD_H235TimeStamp (pctxt, &pvalue->connectTime);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "connectTime", -1);
+   }
+
+   /* decode endTime */
+
+   if (pvalue->m.endTimePresent) {
+      invokeStartElement (pctxt, "endTime", -1);
+
+      stat = asn1PD_H235TimeStamp (pctxt, &pvalue->endTime);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "endTime", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallTerminationCause                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallTerminationCause (OOCTXT* pctxt, H225CallTerminationCause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* releaseCompleteReason */
+         case 0:
+            invokeStartElement (pctxt, "releaseCompleteReason", -1);
+
+            pvalue->u.releaseCompleteReason = ALLOC_ASN1ELEM (pctxt, H225ReleaseCompleteReason);
+
+            stat = asn1PD_H225ReleaseCompleteReason (pctxt, pvalue->u.releaseCompleteReason);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "releaseCompleteReason", -1);
+
+            break;
+
+         /* releaseCompleteCauseIE */
+         case 1:
+            invokeStartElement (pctxt, "releaseCompleteCauseIE", -1);
+
+            pvalue->u.releaseCompleteCauseIE = ALLOC_ASN1ELEM (pctxt, H225CallTerminationCause_releaseCompleteCauseIE);
+
+            stat = asn1PD_H225CallTerminationCause_releaseCompleteCauseIE (pctxt, pvalue->u.releaseCompleteCauseIE);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "releaseCompleteCauseIE", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportChannelInfo                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportChannelInfo (OOCTXT* pctxt, H225TransportChannelInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sendAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.recvAddressPresent = optbit;
+
+   /* decode sendAddress */
+
+   if (pvalue->m.sendAddressPresent) {
+      invokeStartElement (pctxt, "sendAddress", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->sendAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "sendAddress", -1);
+   }
+
+   /* decode recvAddress */
+
+   if (pvalue->m.recvAddressPresent) {
+      invokeStartElement (pctxt, "recvAddress", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->recvAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "recvAddress", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthDetails                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225BandwidthDetails (OOCTXT* pctxt, H225BandwidthDetails* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sender */
+
+   invokeStartElement (pctxt, "sender", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->sender);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->sender);
+
+   invokeEndElement (pctxt, "sender", -1);
+
+   /* decode multicast */
+
+   invokeStartElement (pctxt, "multicast", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->multicast);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->multicast);
+
+   invokeEndElement (pctxt, "multicast", -1);
+
+   /* decode bandwidth */
+
+   invokeStartElement (pctxt, "bandwidth", -1);
+
+   stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandwidth);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "bandwidth", -1);
+
+   /* decode rtcpAddresses */
+
+   invokeStartElement (pctxt, "rtcpAddresses", -1);
+
+   stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->rtcpAddresses);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rtcpAddresses", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallCreditCapability (OOCTXT* pctxt, H225CallCreditCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.canDisplayAmountStringPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.canEnforceDurationLimitPresent = optbit;
+
+   /* decode canDisplayAmountString */
+
+   if (pvalue->m.canDisplayAmountStringPresent) {
+      invokeStartElement (pctxt, "canDisplayAmountString", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->canDisplayAmountString);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->canDisplayAmountString);
+
+      invokeEndElement (pctxt, "canDisplayAmountString", -1);
+   }
+
+   /* decode canEnforceDurationLimit */
+
+   if (pvalue->m.canEnforceDurationLimitPresent) {
+      invokeStartElement (pctxt, "canEnforceDurationLimit", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->canEnforceDurationLimit);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->canEnforceDurationLimit);
+
+      invokeEndElement (pctxt, "canEnforceDurationLimit", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPSession_associatedSessionIds                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RTPSession_associatedSessionIds (OOCTXT* pctxt, H225RTPSession_associatedSessionIds* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1UINT8);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->elem[xx1], 1U, 255U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->elem[xx1]);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPSession                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RTPSession (OOCTXT* pctxt, H225RTPSession* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode rtpAddress */
+
+   invokeStartElement (pctxt, "rtpAddress", -1);
+
+   stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->rtpAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rtpAddress", -1);
+
+   /* decode rtcpAddress */
+
+   invokeStartElement (pctxt, "rtcpAddress", -1);
+
+   stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->rtcpAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rtcpAddress", -1);
+
+   /* decode cname */
+
+   invokeStartElement (pctxt, "cname", -1);
+
+   stat = decodeConstrainedStringEx (pctxt, &pvalue->cname, 0, 8, 7, 7);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, pvalue->cname);
+
+   invokeEndElement (pctxt, "cname", -1);
+
+   /* decode ssrc */
+
+   invokeStartElement (pctxt, "ssrc", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->ssrc, 1U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->ssrc);
+
+   invokeEndElement (pctxt, "ssrc", -1);
+
+   /* decode sessionId */
+
+   invokeStartElement (pctxt, "sessionId", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sessionId, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sessionId);
+
+   invokeEndElement (pctxt, "sessionId", -1);
+
+   /* decode associatedSessionIds */
+
+   invokeStartElement (pctxt, "associatedSessionIds", -1);
+
+   stat = asn1PD_H225RTPSession_associatedSessionIds (pctxt, &pvalue->associatedSessionIds);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "associatedSessionIds", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.multicastPresent = 1;
+
+                     invokeStartElement (pctxt, "multicast", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "multicast", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.bandwidthPresent = 1;
+
+                     invokeStartElement (pctxt, "bandwidth", -1);
+
+                     stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandwidth);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "bandwidth", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225Endpoint                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225Endpoint (OOCTXT* pctxt, H225_SeqOfH225Endpoint* pvalue)
+{
+   int stat = ASN_OK;
+   H225Endpoint* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225Endpoint);
+
+         stat = asn1PD_H225Endpoint (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AuthenticationMechanism                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225AuthenticationMechanism (OOCTXT* pctxt, H225_SeqOfH225AuthenticationMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   H235AuthenticationMechanism* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H235AuthenticationMechanism);
+
+         stat = asn1PD_H235AuthenticationMechanism (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRequest_algorithmOIDs                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GatekeeperRequest_algorithmOIDs (OOCTXT* pctxt, H225GatekeeperRequest_algorithmOIDs* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1OBJID);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeObjectIdentifier (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeOidValue (pctxt, pvalue->elem[xx1].numids, pvalue->elem[xx1].subid);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225IntegrityMechanism                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225IntegrityMechanism (OOCTXT* pctxt, H225_SeqOfH225IntegrityMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   H225IntegrityMechanism* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225IntegrityMechanism);
+
+         stat = asn1PD_H225IntegrityMechanism (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRequest                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GatekeeperRequest (OOCTXT* pctxt, H225GatekeeperRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatekeeperIdentifierPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callServicesPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endpointAliasPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode rasAddress */
+
+   invokeStartElement (pctxt, "rasAddress", -1);
+
+   stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rasAddress", -1);
+
+   /* decode endpointType */
+
+   invokeStartElement (pctxt, "endpointType", -1);
+
+   stat = asn1PD_H225EndpointType (pctxt, &pvalue->endpointType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointType", -1);
+
+   /* decode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+      stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+   }
+
+   /* decode callServices */
+
+   if (pvalue->m.callServicesPresent) {
+      invokeStartElement (pctxt, "callServices", -1);
+
+      stat = asn1PD_H225QseriesOptions (pctxt, &pvalue->callServices);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callServices", -1);
+   }
+
+   /* decode endpointAlias */
+
+   if (pvalue->m.endpointAliasPresent) {
+      invokeStartElement (pctxt, "endpointAlias", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "endpointAlias", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 10 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.alternateEndpointsPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateEndpoints", -1);
+
+                     stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateEndpoints", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.authenticationCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "authenticationCapability", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AuthenticationMechanism (pctxt, &pvalue->authenticationCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "authenticationCapability", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.algorithmOIDsPresent = 1;
+
+                     invokeStartElement (pctxt, "algorithmOIDs", -1);
+
+                     stat = asn1PD_H225GatekeeperRequest_algorithmOIDs (pctxt, &pvalue->algorithmOIDs);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "algorithmOIDs", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.integrityPresent = 1;
+
+                     invokeStartElement (pctxt, "integrity", -1);
+
+                     stat = asn1PD_H225_SeqOfH225IntegrityMechanism (pctxt, &pvalue->integrity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrity", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.supportsAltGKPresent = 1;
+
+                     invokeStartElement (pctxt, "supportsAltGK", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "supportsAltGK", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperConfirm                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GatekeeperConfirm (OOCTXT* pctxt, H225GatekeeperConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatekeeperIdentifierPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+      stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+   }
+
+   /* decode rasAddress */
+
+   invokeStartElement (pctxt, "rasAddress", -1);
+
+   stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rasAddress", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 9 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.alternateGatekeeperPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateGatekeeper", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateGatekeeper", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.authenticationModePresent = 1;
+
+                     invokeStartElement (pctxt, "authenticationMode", -1);
+
+                     stat = asn1PD_H235AuthenticationMechanism (pctxt, &pvalue->authenticationMode);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "authenticationMode", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.algorithmOIDPresent = 1;
+
+                     invokeStartElement (pctxt, "algorithmOID", -1);
+
+                     stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+                     if (stat != ASN_OK) return stat;
+                     invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
+
+                     invokeEndElement (pctxt, "algorithmOID", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.integrityPresent = 1;
+
+                     invokeStartElement (pctxt, "integrity", -1);
+
+                     stat = asn1PD_H225_SeqOfH225IntegrityMechanism (pctxt, &pvalue->integrity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrity", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRejectReason                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GatekeeperRejectReason (OOCTXT* pctxt, H225GatekeeperRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* resourceUnavailable */
+         case 0:
+            invokeStartElement (pctxt, "resourceUnavailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "resourceUnavailable", -1);
+
+            break;
+
+         /* terminalExcluded */
+         case 1:
+            invokeStartElement (pctxt, "terminalExcluded", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "terminalExcluded", -1);
+
+            break;
+
+         /* invalidRevision */
+         case 2:
+            invokeStartElement (pctxt, "invalidRevision", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidRevision", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 3:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* securityDenial */
+         case 5:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* genericDataReason */
+         case 6:
+            invokeStartElement (pctxt, "genericDataReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "genericDataReason", -1);
+
+            break;
+
+         /* neededFeatureNotSupported */
+         case 7:
+            invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
+
+            break;
+
+         /* securityError */
+         case 8:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors);
+
+            stat = asn1PD_H225SecurityErrors (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperReject                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225GatekeeperReject (OOCTXT* pctxt, H225GatekeeperReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatekeeperIdentifierPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+      stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+   }
+
+   /* decode rejectReason */
+
+   invokeStartElement (pctxt, "rejectReason", -1);
+
+   stat = asn1PD_H225GatekeeperRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectReason", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 6 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.altGKInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "altGKInfo", -1);
+
+                     stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "altGKInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AddressPattern                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225AddressPattern (OOCTXT* pctxt, H225_SeqOfH225AddressPattern* pvalue)
+{
+   int stat = ASN_OK;
+   H225AddressPattern* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AddressPattern);
+
+         stat = asn1PD_H225AddressPattern (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225H248PackagesDescriptor                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225H248PackagesDescriptor (OOCTXT* pctxt, H225_SeqOfH225H248PackagesDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, H225H248PackagesDescriptor);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H225H248PackagesDescriptor (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRequest                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RegistrationRequest (OOCTXT* pctxt, H225RegistrationRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalAliasPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatekeeperIdentifierPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode discoveryComplete */
+
+   invokeStartElement (pctxt, "discoveryComplete", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->discoveryComplete);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->discoveryComplete);
+
+   invokeEndElement (pctxt, "discoveryComplete", -1);
+
+   /* decode callSignalAddress */
+
+   invokeStartElement (pctxt, "callSignalAddress", -1);
+
+   stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callSignalAddress", -1);
+
+   /* decode rasAddress */
+
+   invokeStartElement (pctxt, "rasAddress", -1);
+
+   stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rasAddress", -1);
+
+   /* decode terminalType */
+
+   invokeStartElement (pctxt, "terminalType", -1);
+
+   stat = asn1PD_H225EndpointType (pctxt, &pvalue->terminalType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalType", -1);
+
+   /* decode terminalAlias */
+
+   if (pvalue->m.terminalAliasPresent) {
+      invokeStartElement (pctxt, "terminalAlias", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminalAlias", -1);
+   }
+
+   /* decode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+      stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+   }
+
+   /* decode endpointVendor */
+
+   invokeStartElement (pctxt, "endpointVendor", -1);
+
+   stat = asn1PD_H225VendorIdentifier (pctxt, &pvalue->endpointVendor);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointVendor", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 23 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.alternateEndpointsPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateEndpoints", -1);
+
+                     stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateEndpoints", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.timeToLivePresent = 1;
+
+                     invokeStartElement (pctxt, "timeToLive", -1);
+
+                     stat = asn1PD_H225TimeToLive (pctxt, &pvalue->timeToLive);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "timeToLive", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.keepAlivePresent = 1;
+
+                     invokeStartElement (pctxt, "keepAlive", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->keepAlive);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->keepAlive);
+
+                     invokeEndElement (pctxt, "keepAlive", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.endpointIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+                     stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "endpointIdentifier", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.willSupplyUUIEsPresent = 1;
+
+                     invokeStartElement (pctxt, "willSupplyUUIEs", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->willSupplyUUIEs);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->willSupplyUUIEs);
+
+                     invokeEndElement (pctxt, "willSupplyUUIEs", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.maintainConnectionPresent = 1;
+
+                     invokeStartElement (pctxt, "maintainConnection", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maintainConnection);
+
+                     invokeEndElement (pctxt, "maintainConnection", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.alternateTransportAddressesPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateTransportAddresses", -1);
+
+                     stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateTransportAddresses", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.additiveRegistrationPresent = 1;
+
+                     invokeStartElement (pctxt, "additiveRegistration", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "additiveRegistration", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.terminalAliasPatternPresent = 1;
+
+                     invokeStartElement (pctxt, "terminalAliasPattern", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AddressPattern (pctxt, &pvalue->terminalAliasPattern);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "terminalAliasPattern", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.supportsAltGKPresent = 1;
+
+                     invokeStartElement (pctxt, "supportsAltGK", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "supportsAltGK", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.usageReportingCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "usageReportingCapability", -1);
+
+                     stat = asn1PD_H225RasUsageInfoTypes (pctxt, &pvalue->usageReportingCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "usageReportingCapability", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 15:
+                     pvalue->m.supportedH248PackagesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedH248Packages", -1);
+
+                     stat = asn1PD_H225_SeqOfH225H248PackagesDescriptor (pctxt, &pvalue->supportedH248Packages);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedH248Packages", -1);
+                     break;
+
+                  case 16:
+                     pvalue->m.callCreditCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "callCreditCapability", -1);
+
+                     stat = asn1PD_H225CallCreditCapability (pctxt, &pvalue->callCreditCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callCreditCapability", -1);
+                     break;
+
+                  case 17:
+                     pvalue->m.capacityReportingCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacityReportingCapability", -1);
+
+                     stat = asn1PD_H225CapacityReportingCapability (pctxt, &pvalue->capacityReportingCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacityReportingCapability", -1);
+                     break;
+
+                  case 18:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 19:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 20:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  case 21:
+                     pvalue->m.restartPresent = 1;
+
+                     invokeStartElement (pctxt, "restart", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "restart", -1);
+                     break;
+
+                  case 22:
+                     pvalue->m.supportsACFSequencesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportsACFSequences", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "supportsACFSequences", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationConfirm_preGrantedARQ                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RegistrationConfirm_preGrantedARQ (OOCTXT* pctxt, H225RegistrationConfirm_preGrantedARQ* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode makeCall */
+
+   invokeStartElement (pctxt, "makeCall", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->makeCall);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->makeCall);
+
+   invokeEndElement (pctxt, "makeCall", -1);
+
+   /* decode useGKCallSignalAddressToMakeCall */
+
+   invokeStartElement (pctxt, "useGKCallSignalAddressToMakeCall", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->useGKCallSignalAddressToMakeCall);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->useGKCallSignalAddressToMakeCall);
+
+   invokeEndElement (pctxt, "useGKCallSignalAddressToMakeCall", -1);
+
+   /* decode answerCall */
+
+   invokeStartElement (pctxt, "answerCall", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->answerCall);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->answerCall);
+
+   invokeEndElement (pctxt, "answerCall", -1);
+
+   /* decode useGKCallSignalAddressToAnswer */
+
+   invokeStartElement (pctxt, "useGKCallSignalAddressToAnswer", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->useGKCallSignalAddressToAnswer);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->useGKCallSignalAddressToAnswer);
+
+   invokeEndElement (pctxt, "useGKCallSignalAddressToAnswer", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 4 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.irrFrequencyInCallPresent = 1;
+
+                     invokeStartElement (pctxt, "irrFrequencyInCall", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->irrFrequencyInCall, 1U, 65535U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->irrFrequencyInCall);
+
+                     invokeEndElement (pctxt, "irrFrequencyInCall", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.totalBandwidthRestrictionPresent = 1;
+
+                     invokeStartElement (pctxt, "totalBandwidthRestriction", -1);
+
+                     stat = asn1PD_H225BandWidth (pctxt, &pvalue->totalBandwidthRestriction);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "totalBandwidthRestriction", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.alternateTransportAddressesPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateTransportAddresses", -1);
+
+                     stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateTransportAddresses", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.useSpecifiedTransportPresent = 1;
+
+                     invokeStartElement (pctxt, "useSpecifiedTransport", -1);
+
+                     stat = asn1PD_H225UseSpecifiedTransport (pctxt, &pvalue->useSpecifiedTransport);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "useSpecifiedTransport", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225RasUsageSpecification                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225RasUsageSpecification (OOCTXT* pctxt, H225_SeqOfH225RasUsageSpecification* pvalue)
+{
+   int stat = ASN_OK;
+   H225RasUsageSpecification* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225RasUsageSpecification);
+
+         stat = asn1PD_H225RasUsageSpecification (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationConfirm                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RegistrationConfirm (OOCTXT* pctxt, H225RegistrationConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalAliasPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatekeeperIdentifierPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode callSignalAddress */
+
+   invokeStartElement (pctxt, "callSignalAddress", -1);
+
+   stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callSignalAddress", -1);
+
+   /* decode terminalAlias */
+
+   if (pvalue->m.terminalAliasPresent) {
+      invokeStartElement (pctxt, "terminalAlias", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminalAlias", -1);
+   }
+
+   /* decode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+      stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+   }
+
+   /* decode endpointIdentifier */
+
+   invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+   stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 17 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.alternateGatekeeperPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateGatekeeper", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateGatekeeper", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.timeToLivePresent = 1;
+
+                     invokeStartElement (pctxt, "timeToLive", -1);
+
+                     stat = asn1PD_H225TimeToLive (pctxt, &pvalue->timeToLive);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "timeToLive", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.willRespondToIRRPresent = 1;
+
+                     invokeStartElement (pctxt, "willRespondToIRR", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->willRespondToIRR);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->willRespondToIRR);
+
+                     invokeEndElement (pctxt, "willRespondToIRR", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.preGrantedARQPresent = 1;
+
+                     invokeStartElement (pctxt, "preGrantedARQ", -1);
+
+                     stat = asn1PD_H225RegistrationConfirm_preGrantedARQ (pctxt, &pvalue->preGrantedARQ);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "preGrantedARQ", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.maintainConnectionPresent = 1;
+
+                     invokeStartElement (pctxt, "maintainConnection", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maintainConnection);
+
+                     invokeEndElement (pctxt, "maintainConnection", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.supportsAdditiveRegistrationPresent = 1;
+
+                     invokeStartElement (pctxt, "supportsAdditiveRegistration", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "supportsAdditiveRegistration", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.terminalAliasPatternPresent = 1;
+
+                     invokeStartElement (pctxt, "terminalAliasPattern", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AddressPattern (pctxt, &pvalue->terminalAliasPattern);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "terminalAliasPattern", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.usageSpecPresent = 1;
+
+                     invokeStartElement (pctxt, "usageSpec", -1);
+
+                     stat = asn1PD_H225_SeqOfH225RasUsageSpecification (pctxt, &pvalue->usageSpec);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "usageSpec", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.featureServerAliasPresent = 1;
+
+                     invokeStartElement (pctxt, "featureServerAlias", -1);
+
+                     stat = asn1PD_H225AliasAddress (pctxt, &pvalue->featureServerAlias);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureServerAlias", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.capacityReportingSpecPresent = 1;
+
+                     invokeStartElement (pctxt, "capacityReportingSpec", -1);
+
+                     stat = asn1PD_H225CapacityReportingSpecification (pctxt, &pvalue->capacityReportingSpec);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacityReportingSpec", -1);
+                     break;
+
+                  case 15:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 16:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRejectReason_invalidTerminalAliases           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RegistrationRejectReason_invalidTerminalAliases (OOCTXT* pctxt, H225RegistrationRejectReason_invalidTerminalAliases* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalAliasPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalAliasPatternPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.supportedPrefixesPresent = optbit;
+
+   /* decode terminalAlias */
+
+   if (pvalue->m.terminalAliasPresent) {
+      invokeStartElement (pctxt, "terminalAlias", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminalAlias", -1);
+   }
+
+   /* decode terminalAliasPattern */
+
+   if (pvalue->m.terminalAliasPatternPresent) {
+      invokeStartElement (pctxt, "terminalAliasPattern", -1);
+
+      stat = asn1PD_H225_SeqOfH225AddressPattern (pctxt, &pvalue->terminalAliasPattern);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminalAliasPattern", -1);
+   }
+
+   /* decode supportedPrefixes */
+
+   if (pvalue->m.supportedPrefixesPresent) {
+      invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+      stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "supportedPrefixes", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRejectReason                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RegistrationRejectReason (OOCTXT* pctxt, H225RegistrationRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* discoveryRequired */
+         case 0:
+            invokeStartElement (pctxt, "discoveryRequired", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "discoveryRequired", -1);
+
+            break;
+
+         /* invalidRevision */
+         case 1:
+            invokeStartElement (pctxt, "invalidRevision", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidRevision", -1);
+
+            break;
+
+         /* invalidCallSignalAddress */
+         case 2:
+            invokeStartElement (pctxt, "invalidCallSignalAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidCallSignalAddress", -1);
+
+            break;
+
+         /* invalidRASAddress */
+         case 3:
+            invokeStartElement (pctxt, "invalidRASAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidRASAddress", -1);
+
+            break;
+
+         /* duplicateAlias */
+         case 4:
+            invokeStartElement (pctxt, "duplicateAlias", -1);
+
+            pvalue->u.duplicateAlias = ALLOC_ASN1ELEM (pctxt, H225_SeqOfH225AliasAddress);
+
+            stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, pvalue->u.duplicateAlias);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "duplicateAlias", -1);
+
+            break;
+
+         /* invalidTerminalType */
+         case 5:
+            invokeStartElement (pctxt, "invalidTerminalType", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidTerminalType", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 6:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         /* transportNotSupported */
+         case 7:
+            invokeStartElement (pctxt, "transportNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transportNotSupported", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 9;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* transportQOSNotSupported */
+         case 9:
+            invokeStartElement (pctxt, "transportQOSNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transportQOSNotSupported", -1);
+
+            break;
+
+         /* resourceUnavailable */
+         case 10:
+            invokeStartElement (pctxt, "resourceUnavailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "resourceUnavailable", -1);
+
+            break;
+
+         /* invalidAlias */
+         case 11:
+            invokeStartElement (pctxt, "invalidAlias", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidAlias", -1);
+
+            break;
+
+         /* securityDenial */
+         case 12:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* fullRegistrationRequired */
+         case 13:
+            invokeStartElement (pctxt, "fullRegistrationRequired", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "fullRegistrationRequired", -1);
+
+            break;
+
+         /* additiveRegistrationNotSupported */
+         case 14:
+            invokeStartElement (pctxt, "additiveRegistrationNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "additiveRegistrationNotSupported", -1);
+
+            break;
+
+         /* invalidTerminalAliases */
+         case 15:
+            invokeStartElement (pctxt, "invalidTerminalAliases", -1);
+
+            pvalue->u.invalidTerminalAliases = ALLOC_ASN1ELEM (pctxt, H225RegistrationRejectReason_invalidTerminalAliases);
+
+            stat = asn1PD_H225RegistrationRejectReason_invalidTerminalAliases (pctxt, pvalue->u.invalidTerminalAliases);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "invalidTerminalAliases", -1);
+
+            break;
+
+         /* genericDataReason */
+         case 16:
+            invokeStartElement (pctxt, "genericDataReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "genericDataReason", -1);
+
+            break;
+
+         /* neededFeatureNotSupported */
+         case 17:
+            invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
+
+            break;
+
+         /* securityError */
+         case 18:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors);
+
+            stat = asn1PD_H225SecurityErrors (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationReject                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RegistrationReject (OOCTXT* pctxt, H225RegistrationReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.gatekeeperIdentifierPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode rejectReason */
+
+   invokeStartElement (pctxt, "rejectReason", -1);
+
+   stat = asn1PD_H225RegistrationRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectReason", -1);
+
+   /* decode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+      stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 6 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.altGKInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "altGKInfo", -1);
+
+                     stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "altGKInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregRequestReason                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225UnregRequestReason (OOCTXT* pctxt, H225UnregRequestReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* reregistrationRequired */
+         case 0:
+            invokeStartElement (pctxt, "reregistrationRequired", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "reregistrationRequired", -1);
+
+            break;
+
+         /* ttlExpired */
+         case 1:
+            invokeStartElement (pctxt, "ttlExpired", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "ttlExpired", -1);
+
+            break;
+
+         /* securityDenial */
+         case 2:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 3:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* maintenance */
+         case 5:
+            invokeStartElement (pctxt, "maintenance", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "maintenance", -1);
+
+            break;
+
+         /* securityError */
+         case 6:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
+
+            stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationRequest                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225UnregistrationRequest (OOCTXT* pctxt, H225UnregistrationRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endpointAliasPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endpointIdentifierPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode callSignalAddress */
+
+   invokeStartElement (pctxt, "callSignalAddress", -1);
+
+   stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callSignalAddress", -1);
+
+   /* decode endpointAlias */
+
+   if (pvalue->m.endpointAliasPresent) {
+      invokeStartElement (pctxt, "endpointAlias", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "endpointAlias", -1);
+   }
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode endpointIdentifier */
+
+   if (pvalue->m.endpointIdentifierPresent) {
+      invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+      stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "endpointIdentifier", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 10 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.alternateEndpointsPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateEndpoints", -1);
+
+                     stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateEndpoints", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.gatekeeperIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+                     stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.reasonPresent = 1;
+
+                     invokeStartElement (pctxt, "reason", -1);
+
+                     stat = asn1PD_H225UnregRequestReason (pctxt, &pvalue->reason);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "reason", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.endpointAliasPatternPresent = 1;
+
+                     invokeStartElement (pctxt, "endpointAliasPattern", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AddressPattern (pctxt, &pvalue->endpointAliasPattern);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "endpointAliasPattern", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.supportedPrefixesPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedPrefixes", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedPrefixes", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.alternateGatekeeperPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateGatekeeper", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateGatekeeper", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationConfirm                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225UnregistrationConfirm (OOCTXT* pctxt, H225UnregistrationConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 4 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregRejectReason                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225UnregRejectReason (OOCTXT* pctxt, H225UnregRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* notCurrentlyRegistered */
+         case 0:
+            invokeStartElement (pctxt, "notCurrentlyRegistered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "notCurrentlyRegistered", -1);
+
+            break;
+
+         /* callInProgress */
+         case 1:
+            invokeStartElement (pctxt, "callInProgress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "callInProgress", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 2:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* permissionDenied */
+         case 4:
+            invokeStartElement (pctxt, "permissionDenied", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "permissionDenied", -1);
+
+            break;
+
+         /* securityDenial */
+         case 5:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* securityError */
+         case 6:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
+
+            stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationReject                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225UnregistrationReject (OOCTXT* pctxt, H225UnregistrationReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode rejectReason */
+
+   invokeStartElement (pctxt, "rejectReason", -1);
+
+   stat = asn1PD_H225UnregRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectReason", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 5 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.altGKInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "altGKInfo", -1);
+
+                     stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "altGKInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallModel                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225CallModel (OOCTXT* pctxt, H225CallModel* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* direct */
+         case 0:
+            invokeStartElement (pctxt, "direct", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "direct", -1);
+
+            break;
+
+         /* gatekeeperRouted */
+         case 1:
+            invokeStartElement (pctxt, "gatekeeperRouted", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "gatekeeperRouted", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportQOS                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225TransportQOS (OOCTXT* pctxt, H225TransportQOS* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* endpointControlled */
+         case 0:
+            invokeStartElement (pctxt, "endpointControlled", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "endpointControlled", -1);
+
+            break;
+
+         /* gatekeeperControlled */
+         case 1:
+            invokeStartElement (pctxt, "gatekeeperControlled", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "gatekeeperControlled", -1);
+
+            break;
+
+         /* noControl */
+         case 2:
+            invokeStartElement (pctxt, "noControl", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noControl", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AdmissionRequest (OOCTXT* pctxt, H225AdmissionRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callModelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destinationInfoPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destCallSignalAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destExtraCallInfoPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.srcCallSignalAddressPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callServicesPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode callType */
+
+   invokeStartElement (pctxt, "callType", -1);
+
+   stat = asn1PD_H225CallType (pctxt, &pvalue->callType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callType", -1);
+
+   /* decode callModel */
+
+   if (pvalue->m.callModelPresent) {
+      invokeStartElement (pctxt, "callModel", -1);
+
+      stat = asn1PD_H225CallModel (pctxt, &pvalue->callModel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callModel", -1);
+   }
+
+   /* decode endpointIdentifier */
+
+   invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+   stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointIdentifier", -1);
+
+   /* decode destinationInfo */
+
+   if (pvalue->m.destinationInfoPresent) {
+      invokeStartElement (pctxt, "destinationInfo", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destinationInfo", -1);
+   }
+
+   /* decode destCallSignalAddress */
+
+   if (pvalue->m.destCallSignalAddressPresent) {
+      invokeStartElement (pctxt, "destCallSignalAddress", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destCallSignalAddress", -1);
+   }
+
+   /* decode destExtraCallInfo */
+
+   if (pvalue->m.destExtraCallInfoPresent) {
+      invokeStartElement (pctxt, "destExtraCallInfo", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destExtraCallInfo", -1);
+   }
+
+   /* decode srcInfo */
+
+   invokeStartElement (pctxt, "srcInfo", -1);
+
+   stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->srcInfo);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "srcInfo", -1);
+
+   /* decode srcCallSignalAddress */
+
+   if (pvalue->m.srcCallSignalAddressPresent) {
+      invokeStartElement (pctxt, "srcCallSignalAddress", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->srcCallSignalAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "srcCallSignalAddress", -1);
+   }
+
+   /* decode bandWidth */
+
+   invokeStartElement (pctxt, "bandWidth", -1);
+
+   stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "bandWidth", -1);
+
+   /* decode callReferenceValue */
+
+   invokeStartElement (pctxt, "callReferenceValue", -1);
+
+   stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callReferenceValue", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode callServices */
+
+   if (pvalue->m.callServicesPresent) {
+      invokeStartElement (pctxt, "callServices", -1);
+
+      stat = asn1PD_H225QseriesOptions (pctxt, &pvalue->callServices);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callServices", -1);
+   }
+
+   /* decode conferenceID */
+
+   invokeStartElement (pctxt, "conferenceID", -1);
+
+   stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceID", -1);
+
+   /* decode activeMC */
+
+   invokeStartElement (pctxt, "activeMC", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->activeMC);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->activeMC);
+
+   invokeEndElement (pctxt, "activeMC", -1);
+
+   /* decode answerCall */
+
+   invokeStartElement (pctxt, "answerCall", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->answerCall);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->answerCall);
+
+   invokeEndElement (pctxt, "answerCall", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 19 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.canMapAliasPresent = 1;
+
+                     invokeStartElement (pctxt, "canMapAlias", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->canMapAlias);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->canMapAlias);
+
+                     invokeEndElement (pctxt, "canMapAlias", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.srcAlternativesPresent = 1;
+
+                     invokeStartElement (pctxt, "srcAlternatives", -1);
+
+                     stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->srcAlternatives);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "srcAlternatives", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.destAlternativesPresent = 1;
+
+                     invokeStartElement (pctxt, "destAlternatives", -1);
+
+                     stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->destAlternatives);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destAlternatives", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.gatekeeperIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+                     stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.transportQOSPresent = 1;
+
+                     invokeStartElement (pctxt, "transportQOS", -1);
+
+                     stat = asn1PD_H225TransportQOS (pctxt, &pvalue->transportQOS);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "transportQOS", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.willSupplyUUIEsPresent = 1;
+
+                     invokeStartElement (pctxt, "willSupplyUUIEs", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->willSupplyUUIEs);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->willSupplyUUIEs);
+
+                     invokeEndElement (pctxt, "willSupplyUUIEs", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.callLinkagePresent = 1;
+
+                     invokeStartElement (pctxt, "callLinkage", -1);
+
+                     stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callLinkage", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.gatewayDataRatePresent = 1;
+
+                     invokeStartElement (pctxt, "gatewayDataRate", -1);
+
+                     stat = asn1PD_H225DataRate (pctxt, &pvalue->gatewayDataRate);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "gatewayDataRate", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.desiredProtocolsPresent = 1;
+
+                     invokeStartElement (pctxt, "desiredProtocols", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->desiredProtocols);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "desiredProtocols", -1);
+                     break;
+
+                  case 15:
+                     pvalue->m.desiredTunnelledProtocolPresent = 1;
+
+                     invokeStartElement (pctxt, "desiredTunnelledProtocol", -1);
+
+                     stat = asn1PD_H225TunnelledProtocol (pctxt, &pvalue->desiredTunnelledProtocol);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "desiredTunnelledProtocol", -1);
+                     break;
+
+                  case 16:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 17:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  case 18:
+                     pvalue->m.canMapSrcAliasPresent = 1;
+
+                     invokeStartElement (pctxt, "canMapSrcAlias", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->canMapSrcAlias);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->canMapSrcAlias);
+
+                     invokeEndElement (pctxt, "canMapSrcAlias", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UUIEsRequested                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225UUIEsRequested (OOCTXT* pctxt, H225UUIEsRequested* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode setup */
+
+   invokeStartElement (pctxt, "setup", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->setup);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->setup);
+
+   invokeEndElement (pctxt, "setup", -1);
+
+   /* decode callProceeding */
+
+   invokeStartElement (pctxt, "callProceeding", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->callProceeding);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->callProceeding);
+
+   invokeEndElement (pctxt, "callProceeding", -1);
+
+   /* decode connect */
+
+   invokeStartElement (pctxt, "connect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->connect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->connect);
+
+   invokeEndElement (pctxt, "connect", -1);
+
+   /* decode alerting */
+
+   invokeStartElement (pctxt, "alerting", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->alerting);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->alerting);
+
+   invokeEndElement (pctxt, "alerting", -1);
+
+   /* decode information */
+
+   invokeStartElement (pctxt, "information", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->information);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->information);
+
+   invokeEndElement (pctxt, "information", -1);
+
+   /* decode releaseComplete */
+
+   invokeStartElement (pctxt, "releaseComplete", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->releaseComplete);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->releaseComplete);
+
+   invokeEndElement (pctxt, "releaseComplete", -1);
+
+   /* decode facility */
+
+   invokeStartElement (pctxt, "facility", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->facility);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->facility);
+
+   invokeEndElement (pctxt, "facility", -1);
+
+   /* decode progress */
+
+   invokeStartElement (pctxt, "progress", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->progress);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->progress);
+
+   invokeEndElement (pctxt, "progress", -1);
+
+   /* decode empty */
+
+   invokeStartElement (pctxt, "empty", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->empty);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->empty);
+
+   invokeEndElement (pctxt, "empty", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 4 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.statusPresent = 1;
+
+                     invokeStartElement (pctxt, "status", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->status);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->status);
+
+                     invokeEndElement (pctxt, "status", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.statusInquiryPresent = 1;
+
+                     invokeStartElement (pctxt, "statusInquiry", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->statusInquiry);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->statusInquiry);
+
+                     invokeEndElement (pctxt, "statusInquiry", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.setupAcknowledgePresent = 1;
+
+                     invokeStartElement (pctxt, "setupAcknowledge", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->setupAcknowledge);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->setupAcknowledge);
+
+                     invokeEndElement (pctxt, "setupAcknowledge", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.notifyPresent = 1;
+
+                     invokeStartElement (pctxt, "notify", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->notify);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->notify);
+
+                     invokeEndElement (pctxt, "notify", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionConfirm_language                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AdmissionConfirm_language (OOCTXT* pctxt, H225AdmissionConfirm_language* pvalue)
+{
+   static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1IA5String);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      addSizeConstraint (pctxt, &element_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->elem[xx1], 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->elem[xx1]);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AdmissionConfirm (OOCTXT* pctxt, H225AdmissionConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.irrFrequencyPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode bandWidth */
+
+   invokeStartElement (pctxt, "bandWidth", -1);
+
+   stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "bandWidth", -1);
+
+   /* decode callModel */
+
+   invokeStartElement (pctxt, "callModel", -1);
+
+   stat = asn1PD_H225CallModel (pctxt, &pvalue->callModel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callModel", -1);
+
+   /* decode destCallSignalAddress */
+
+   invokeStartElement (pctxt, "destCallSignalAddress", -1);
+
+   stat = asn1PD_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "destCallSignalAddress", -1);
+
+   /* decode irrFrequency */
+
+   if (pvalue->m.irrFrequencyPresent) {
+      invokeStartElement (pctxt, "irrFrequency", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->irrFrequency, 1U, 65535U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->irrFrequency);
+
+      invokeEndElement (pctxt, "irrFrequency", -1);
+   }
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 22 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.destinationInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "destinationInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destinationInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.destExtraCallInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "destExtraCallInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destExtraCallInfo", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.destinationTypePresent = 1;
+
+                     invokeStartElement (pctxt, "destinationType", -1);
+
+                     stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationType);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destinationType", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.remoteExtensionAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "remoteExtensionAddress", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "remoteExtensionAddress", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.alternateEndpointsPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateEndpoints", -1);
+
+                     stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateEndpoints", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.transportQOSPresent = 1;
+
+                     invokeStartElement (pctxt, "transportQOS", -1);
+
+                     stat = asn1PD_H225TransportQOS (pctxt, &pvalue->transportQOS);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "transportQOS", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.willRespondToIRRPresent = 1;
+
+                     invokeStartElement (pctxt, "willRespondToIRR", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->willRespondToIRR);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->willRespondToIRR);
+
+                     invokeEndElement (pctxt, "willRespondToIRR", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.uuiesRequestedPresent = 1;
+
+                     invokeStartElement (pctxt, "uuiesRequested", -1);
+
+                     stat = asn1PD_H225UUIEsRequested (pctxt, &pvalue->uuiesRequested);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "uuiesRequested", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.languagePresent = 1;
+
+                     invokeStartElement (pctxt, "language", -1);
+
+                     stat = asn1PD_H225AdmissionConfirm_language (pctxt, &pvalue->language);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "language", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.alternateTransportAddressesPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateTransportAddresses", -1);
+
+                     stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateTransportAddresses", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.useSpecifiedTransportPresent = 1;
+
+                     invokeStartElement (pctxt, "useSpecifiedTransport", -1);
+
+                     stat = asn1PD_H225UseSpecifiedTransport (pctxt, &pvalue->useSpecifiedTransport);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "useSpecifiedTransport", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 15:
+                     pvalue->m.usageSpecPresent = 1;
+
+                     invokeStartElement (pctxt, "usageSpec", -1);
+
+                     stat = asn1PD_H225_SeqOfH225RasUsageSpecification (pctxt, &pvalue->usageSpec);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "usageSpec", -1);
+                     break;
+
+                  case 16:
+                     pvalue->m.supportedProtocolsPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedProtocols", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->supportedProtocols);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedProtocols", -1);
+                     break;
+
+                  case 17:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 18:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 19:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 20:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  case 21:
+                     pvalue->m.modifiedSrcInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "modifiedSrcInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->modifiedSrcInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "modifiedSrcInfo", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225PartyNumber                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225PartyNumber (OOCTXT* pctxt, H225_SeqOfH225PartyNumber* pvalue)
+{
+   int stat = ASN_OK;
+   H225PartyNumber* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225PartyNumber);
+
+         stat = asn1PD_H225PartyNumber (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionRejectReason                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AdmissionRejectReason (OOCTXT* pctxt, H225AdmissionRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* calledPartyNotRegistered */
+         case 0:
+            invokeStartElement (pctxt, "calledPartyNotRegistered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "calledPartyNotRegistered", -1);
+
+            break;
+
+         /* invalidPermission */
+         case 1:
+            invokeStartElement (pctxt, "invalidPermission", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidPermission", -1);
+
+            break;
+
+         /* requestDenied */
+         case 2:
+            invokeStartElement (pctxt, "requestDenied", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "requestDenied", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 3:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         /* callerNotRegistered */
+         case 4:
+            invokeStartElement (pctxt, "callerNotRegistered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "callerNotRegistered", -1);
+
+            break;
+
+         /* routeCallToGatekeeper */
+         case 5:
+            invokeStartElement (pctxt, "routeCallToGatekeeper", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "routeCallToGatekeeper", -1);
+
+            break;
+
+         /* invalidEndpointIdentifier */
+         case 6:
+            invokeStartElement (pctxt, "invalidEndpointIdentifier", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidEndpointIdentifier", -1);
+
+            break;
+
+         /* resourceUnavailable */
+         case 7:
+            invokeStartElement (pctxt, "resourceUnavailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "resourceUnavailable", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 9;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* securityDenial */
+         case 9:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* qosControlNotSupported */
+         case 10:
+            invokeStartElement (pctxt, "qosControlNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "qosControlNotSupported", -1);
+
+            break;
+
+         /* incompleteAddress */
+         case 11:
+            invokeStartElement (pctxt, "incompleteAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "incompleteAddress", -1);
+
+            break;
+
+         /* aliasesInconsistent */
+         case 12:
+            invokeStartElement (pctxt, "aliasesInconsistent", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "aliasesInconsistent", -1);
+
+            break;
+
+         /* routeCallToSCN */
+         case 13:
+            invokeStartElement (pctxt, "routeCallToSCN", -1);
+
+            pvalue->u.routeCallToSCN = ALLOC_ASN1ELEM (pctxt, H225_SeqOfH225PartyNumber);
+
+            stat = asn1PD_H225_SeqOfH225PartyNumber (pctxt, pvalue->u.routeCallToSCN);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "routeCallToSCN", -1);
+
+            break;
+
+         /* exceedsCallCapacity */
+         case 14:
+            invokeStartElement (pctxt, "exceedsCallCapacity", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "exceedsCallCapacity", -1);
+
+            break;
+
+         /* collectDestination */
+         case 15:
+            invokeStartElement (pctxt, "collectDestination", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "collectDestination", -1);
+
+            break;
+
+         /* collectPIN */
+         case 16:
+            invokeStartElement (pctxt, "collectPIN", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "collectPIN", -1);
+
+            break;
+
+         /* genericDataReason */
+         case 17:
+            invokeStartElement (pctxt, "genericDataReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "genericDataReason", -1);
+
+            break;
+
+         /* neededFeatureNotSupported */
+         case 18:
+            invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
+
+            break;
+
+         /* securityErrors */
+         case 19:
+            invokeStartElement (pctxt, "securityErrors", -1);
+
+            pvalue->u.securityErrors = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
+
+            stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityErrors);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityErrors", -1);
+
+            break;
+
+         /* securityDHmismatch */
+         case 20:
+            invokeStartElement (pctxt, "securityDHmismatch", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDHmismatch", -1);
+
+            break;
+
+         /* noRouteToDestination */
+         case 21:
+            invokeStartElement (pctxt, "noRouteToDestination", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noRouteToDestination", -1);
+
+            break;
+
+         /* unallocatedNumber */
+         case 22:
+            invokeStartElement (pctxt, "unallocatedNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unallocatedNumber", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionReject                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225AdmissionReject (OOCTXT* pctxt, H225AdmissionReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode rejectReason */
+
+   invokeStartElement (pctxt, "rejectReason", -1);
+
+   stat = asn1PD_H225AdmissionRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectReason", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 8 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.altGKInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "altGKInfo", -1);
+
+                     stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "altGKInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.callSignalAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "callSignalAddress", -1);
+
+                     stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callSignalAddress", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225BandwidthDetails                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225BandwidthDetails (OOCTXT* pctxt, H225_SeqOfH225BandwidthDetails* pvalue)
+{
+   int stat = ASN_OK;
+   H225BandwidthDetails* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225BandwidthDetails);
+
+         stat = asn1PD_H225BandwidthDetails (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225BandwidthRequest (OOCTXT* pctxt, H225BandwidthRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callTypePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode endpointIdentifier */
+
+   invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+   stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointIdentifier", -1);
+
+   /* decode conferenceID */
+
+   invokeStartElement (pctxt, "conferenceID", -1);
+
+   stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceID", -1);
+
+   /* decode callReferenceValue */
+
+   invokeStartElement (pctxt, "callReferenceValue", -1);
+
+   stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callReferenceValue", -1);
+
+   /* decode callType */
+
+   if (pvalue->m.callTypePresent) {
+      invokeStartElement (pctxt, "callType", -1);
+
+      stat = asn1PD_H225CallType (pctxt, &pvalue->callType);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callType", -1);
+   }
+
+   /* decode bandWidth */
+
+   invokeStartElement (pctxt, "bandWidth", -1);
+
+   stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "bandWidth", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 11 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.gatekeeperIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+                     stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.answeredCallPresent = 1;
+
+                     invokeStartElement (pctxt, "answeredCall", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->answeredCall);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->answeredCall);
+
+                     invokeEndElement (pctxt, "answeredCall", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.callLinkagePresent = 1;
+
+                     invokeStartElement (pctxt, "callLinkage", -1);
+
+                     stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callLinkage", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.usageInformationPresent = 1;
+
+                     invokeStartElement (pctxt, "usageInformation", -1);
+
+                     stat = asn1PD_H225RasUsageInformation (pctxt, &pvalue->usageInformation);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "usageInformation", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.bandwidthDetailsPresent = 1;
+
+                     invokeStartElement (pctxt, "bandwidthDetails", -1);
+
+                     stat = asn1PD_H225_SeqOfH225BandwidthDetails (pctxt, &pvalue->bandwidthDetails);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "bandwidthDetails", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225BandwidthConfirm (OOCTXT* pctxt, H225BandwidthConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode bandWidth */
+
+   invokeStartElement (pctxt, "bandWidth", -1);
+
+   stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "bandWidth", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 5 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandRejectReason                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225BandRejectReason (OOCTXT* pctxt, H225BandRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* notBound */
+         case 0:
+            invokeStartElement (pctxt, "notBound", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "notBound", -1);
+
+            break;
+
+         /* invalidConferenceID */
+         case 1:
+            invokeStartElement (pctxt, "invalidConferenceID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidConferenceID", -1);
+
+            break;
+
+         /* invalidPermission */
+         case 2:
+            invokeStartElement (pctxt, "invalidPermission", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidPermission", -1);
+
+            break;
+
+         /* insufficientResources */
+         case 3:
+            invokeStartElement (pctxt, "insufficientResources", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "insufficientResources", -1);
+
+            break;
+
+         /* invalidRevision */
+         case 4:
+            invokeStartElement (pctxt, "invalidRevision", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidRevision", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 5:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* securityDenial */
+         case 7:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* securityError */
+         case 8:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
+
+            stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthReject                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225BandwidthReject (OOCTXT* pctxt, H225BandwidthReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode rejectReason */
+
+   invokeStartElement (pctxt, "rejectReason", -1);
+
+   stat = asn1PD_H225BandRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectReason", -1);
+
+   /* decode allowedBandWidth */
+
+   invokeStartElement (pctxt, "allowedBandWidth", -1);
+
+   stat = asn1PD_H225BandWidth (pctxt, &pvalue->allowedBandWidth);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "allowedBandWidth", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 5 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.altGKInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "altGKInfo", -1);
+
+                     stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "altGKInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageReason                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225DisengageReason (OOCTXT* pctxt, H225DisengageReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* forcedDrop */
+         case 0:
+            invokeStartElement (pctxt, "forcedDrop", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "forcedDrop", -1);
+
+            break;
+
+         /* normalDrop */
+         case 1:
+            invokeStartElement (pctxt, "normalDrop", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "normalDrop", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 2:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225DisengageRequest (OOCTXT* pctxt, H225DisengageRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode endpointIdentifier */
+
+   invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+   stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointIdentifier", -1);
+
+   /* decode conferenceID */
+
+   invokeStartElement (pctxt, "conferenceID", -1);
+
+   stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceID", -1);
+
+   /* decode callReferenceValue */
+
+   invokeStartElement (pctxt, "callReferenceValue", -1);
+
+   stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callReferenceValue", -1);
+
+   /* decode disengageReason */
+
+   invokeStartElement (pctxt, "disengageReason", -1);
+
+   stat = asn1PD_H225DisengageReason (pctxt, &pvalue->disengageReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "disengageReason", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 13 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.gatekeeperIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+                     stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.answeredCallPresent = 1;
+
+                     invokeStartElement (pctxt, "answeredCall", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->answeredCall);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->answeredCall);
+
+                     invokeEndElement (pctxt, "answeredCall", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.callLinkagePresent = 1;
+
+                     invokeStartElement (pctxt, "callLinkage", -1);
+
+                     stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callLinkage", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.usageInformationPresent = 1;
+
+                     invokeStartElement (pctxt, "usageInformation", -1);
+
+                     stat = asn1PD_H225RasUsageInformation (pctxt, &pvalue->usageInformation);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "usageInformation", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.terminationCausePresent = 1;
+
+                     invokeStartElement (pctxt, "terminationCause", -1);
+
+                     stat = asn1PD_H225CallTerminationCause (pctxt, &pvalue->terminationCause);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "terminationCause", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225DisengageConfirm (OOCTXT* pctxt, H225DisengageConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 7 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.usageInformationPresent = 1;
+
+                     invokeStartElement (pctxt, "usageInformation", -1);
+
+                     stat = asn1PD_H225RasUsageInformation (pctxt, &pvalue->usageInformation);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "usageInformation", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageRejectReason                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225DisengageRejectReason (OOCTXT* pctxt, H225DisengageRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* notRegistered */
+         case 0:
+            invokeStartElement (pctxt, "notRegistered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "notRegistered", -1);
+
+            break;
+
+         /* requestToDropOther */
+         case 1:
+            invokeStartElement (pctxt, "requestToDropOther", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "requestToDropOther", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* securityDenial */
+         case 3:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* securityError */
+         case 4:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
+
+            stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageReject                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225DisengageReject (OOCTXT* pctxt, H225DisengageReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode rejectReason */
+
+   invokeStartElement (pctxt, "rejectReason", -1);
+
+   stat = asn1PD_H225DisengageRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectReason", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 5 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.altGKInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "altGKInfo", -1);
+
+                     stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "altGKInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LocationRequest                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225LocationRequest (OOCTXT* pctxt, H225LocationRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endpointIdentifierPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode endpointIdentifier */
+
+   if (pvalue->m.endpointIdentifierPresent) {
+      invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+      stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "endpointIdentifier", -1);
+   }
+
+   /* decode destinationInfo */
+
+   invokeStartElement (pctxt, "destinationInfo", -1);
+
+   stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "destinationInfo", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode replyAddress */
+
+   invokeStartElement (pctxt, "replyAddress", -1);
+
+   stat = asn1PD_H225TransportAddress (pctxt, &pvalue->replyAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "replyAddress", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 16 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.sourceInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "sourceInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->sourceInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "sourceInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.canMapAliasPresent = 1;
+
+                     invokeStartElement (pctxt, "canMapAlias", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->canMapAlias);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->canMapAlias);
+
+                     invokeEndElement (pctxt, "canMapAlias", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.gatekeeperIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
+
+                     stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.desiredProtocolsPresent = 1;
+
+                     invokeStartElement (pctxt, "desiredProtocols", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->desiredProtocols);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "desiredProtocols", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.desiredTunnelledProtocolPresent = 1;
+
+                     invokeStartElement (pctxt, "desiredTunnelledProtocol", -1);
+
+                     stat = asn1PD_H225TunnelledProtocol (pctxt, &pvalue->desiredTunnelledProtocol);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "desiredTunnelledProtocol", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.hopCountPresent = 1;
+
+                     invokeStartElement (pctxt, "hopCount", -1);
+
+                     stat = decodeConsUInt8 (pctxt, &pvalue->hopCount, 1U, 255U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->hopCount);
+
+                     invokeEndElement (pctxt, "hopCount", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.bandWidthPresent = 1;
+
+                     invokeStartElement (pctxt, "bandWidth", -1);
+
+                     stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "bandWidth", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.sourceEndpointInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "sourceEndpointInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->sourceEndpointInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "sourceEndpointInfo", -1);
+                     break;
+
+                  case 15:
+                     pvalue->m.canMapSrcAliasPresent = 1;
+
+                     invokeStartElement (pctxt, "canMapSrcAlias", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->canMapSrcAlias);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->canMapSrcAlias);
+
+                     invokeEndElement (pctxt, "canMapSrcAlias", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LocationConfirm                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225LocationConfirm (OOCTXT* pctxt, H225LocationConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode callSignalAddress */
+
+   invokeStartElement (pctxt, "callSignalAddress", -1);
+
+   stat = asn1PD_H225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callSignalAddress", -1);
+
+   /* decode rasAddress */
+
+   invokeStartElement (pctxt, "rasAddress", -1);
+
+   stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rasAddress", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 17 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.destinationInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "destinationInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destinationInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.destExtraCallInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "destExtraCallInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destExtraCallInfo", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.destinationTypePresent = 1;
+
+                     invokeStartElement (pctxt, "destinationType", -1);
+
+                     stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationType);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destinationType", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.remoteExtensionAddressPresent = 1;
+
+                     invokeStartElement (pctxt, "remoteExtensionAddress", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "remoteExtensionAddress", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.alternateEndpointsPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateEndpoints", -1);
+
+                     stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateEndpoints", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.alternateTransportAddressesPresent = 1;
+
+                     invokeStartElement (pctxt, "alternateTransportAddresses", -1);
+
+                     stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "alternateTransportAddresses", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.supportedProtocolsPresent = 1;
+
+                     invokeStartElement (pctxt, "supportedProtocols", -1);
+
+                     stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->supportedProtocols);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "supportedProtocols", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.multipleCallsPresent = 1;
+
+                     invokeStartElement (pctxt, "multipleCalls", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipleCalls);
+
+                     invokeEndElement (pctxt, "multipleCalls", -1);
+                     break;
+
+                  case 11:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 12:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  case 13:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  case 14:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  case 15:
+                     pvalue->m.modifiedSrcInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "modifiedSrcInfo", -1);
+
+                     stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->modifiedSrcInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "modifiedSrcInfo", -1);
+                     break;
+
+                  case 16:
+                     pvalue->m.bandWidthPresent = 1;
+
+                     invokeStartElement (pctxt, "bandWidth", -1);
+
+                     stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "bandWidth", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LocationRejectReason                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225LocationRejectReason (OOCTXT* pctxt, H225LocationRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* notRegistered */
+         case 0:
+            invokeStartElement (pctxt, "notRegistered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "notRegistered", -1);
+
+            break;
+
+         /* invalidPermission */
+         case 1:
+            invokeStartElement (pctxt, "invalidPermission", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidPermission", -1);
+
+            break;
+
+         /* requestDenied */
+         case 2:
+            invokeStartElement (pctxt, "requestDenied", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "requestDenied", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 3:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* securityDenial */
+         case 5:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* aliasesInconsistent */
+         case 6:
+            invokeStartElement (pctxt, "aliasesInconsistent", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "aliasesInconsistent", -1);
+
+            break;
+
+         /* routeCalltoSCN */
+         case 7:
+            invokeStartElement (pctxt, "routeCalltoSCN", -1);
+
+            pvalue->u.routeCalltoSCN = ALLOC_ASN1ELEM (pctxt, H225_SeqOfH225PartyNumber);
+
+            stat = asn1PD_H225_SeqOfH225PartyNumber (pctxt, pvalue->u.routeCalltoSCN);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "routeCalltoSCN", -1);
+
+            break;
+
+         /* resourceUnavailable */
+         case 8:
+            invokeStartElement (pctxt, "resourceUnavailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "resourceUnavailable", -1);
+
+            break;
+
+         /* genericDataReason */
+         case 9:
+            invokeStartElement (pctxt, "genericDataReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "genericDataReason", -1);
+
+            break;
+
+         /* neededFeatureNotSupported */
+         case 10:
+            invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
+
+            break;
+
+         /* hopCountExceeded */
+         case 11:
+            invokeStartElement (pctxt, "hopCountExceeded", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hopCountExceeded", -1);
+
+            break;
+
+         /* incompleteAddress */
+         case 12:
+            invokeStartElement (pctxt, "incompleteAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "incompleteAddress", -1);
+
+            break;
+
+         /* securityError */
+         case 13:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
+
+            stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         /* securityDHmismatch */
+         case 14:
+            invokeStartElement (pctxt, "securityDHmismatch", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDHmismatch", -1);
+
+            break;
+
+         /* noRouteToDestination */
+         case 15:
+            invokeStartElement (pctxt, "noRouteToDestination", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noRouteToDestination", -1);
+
+            break;
+
+         /* unallocatedNumber */
+         case 16:
+            invokeStartElement (pctxt, "unallocatedNumber", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unallocatedNumber", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LocationReject                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225LocationReject (OOCTXT* pctxt, H225LocationReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode rejectReason */
+
+   invokeStartElement (pctxt, "rejectReason", -1);
+
+   stat = asn1PD_H225LocationRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectReason", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 7 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.altGKInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "altGKInfo", -1);
+
+                     stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "altGKInfo", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.serviceControlPresent = 1;
+
+                     invokeStartElement (pctxt, "serviceControl", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "serviceControl", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequest                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225InfoRequest (OOCTXT* pctxt, H225InfoRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.replyAddressPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode callReferenceValue */
+
+   invokeStartElement (pctxt, "callReferenceValue", -1);
+
+   stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callReferenceValue", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode replyAddress */
+
+   if (pvalue->m.replyAddressPresent) {
+      invokeStartElement (pctxt, "replyAddress", -1);
+
+      stat = asn1PD_H225TransportAddress (pctxt, &pvalue->replyAddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "replyAddress", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 11 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.uuiesRequestedPresent = 1;
+
+                     invokeStartElement (pctxt, "uuiesRequested", -1);
+
+                     stat = asn1PD_H225UUIEsRequested (pctxt, &pvalue->uuiesRequested);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "uuiesRequested", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.callLinkagePresent = 1;
+
+                     invokeStartElement (pctxt, "callLinkage", -1);
+
+                     stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callLinkage", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.usageInfoRequestedPresent = 1;
+
+                     invokeStartElement (pctxt, "usageInfoRequested", -1);
+
+                     stat = asn1PD_H225RasUsageInfoTypes (pctxt, &pvalue->usageInfoRequested);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "usageInfoRequested", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.segmentedResponseSupportedPresent = 1;
+
+                     invokeStartElement (pctxt, "segmentedResponseSupported", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "segmentedResponseSupported", -1);
+                     break;
+
+                  case 8:
+                     pvalue->m.nextSegmentRequestedPresent = 1;
+
+                     invokeStartElement (pctxt, "nextSegmentRequested", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->nextSegmentRequested, 0U, 65535U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->nextSegmentRequested);
+
+                     invokeEndElement (pctxt, "nextSegmentRequested", -1);
+                     break;
+
+                  case 9:
+                     pvalue->m.capacityInfoRequestedPresent = 1;
+
+                     invokeStartElement (pctxt, "capacityInfoRequested", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "capacityInfoRequested", -1);
+                     break;
+
+                  case 10:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225RTPSession                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225RTPSession (OOCTXT* pctxt, H225_SeqOfH225RTPSession* pvalue)
+{
+   int stat = ASN_OK;
+   H225RTPSession* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225RTPSession);
+
+         stat = asn1PD_H225RTPSession (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportChannelInfo                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225TransportChannelInfo (OOCTXT* pctxt, H225_SeqOfH225TransportChannelInfo* pvalue)
+{
+   int stat = ASN_OK;
+   H225TransportChannelInfo* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225TransportChannelInfo);
+
+         stat = asn1PD_H225TransportChannelInfo (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ConferenceIdentifier                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225ConferenceIdentifier (OOCTXT* pctxt, H225_SeqOfH225ConferenceIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, H225ConferenceIdentifier);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse_perCallInfo_element_pdu_element       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode h323pdu */
+
+   invokeStartElement (pctxt, "h323pdu", -1);
+
+   stat = asn1PD_H225H323_UU_PDU (pctxt, &pvalue->h323pdu);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "h323pdu", -1);
+
+   /* decode sent */
+
+   invokeStartElement (pctxt, "sent", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->sent);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->sent);
+
+   invokeEndElement (pctxt, "sent", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_el  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue)
+{
+   int stat = ASN_OK;
+   H225InfoRequestResponse_perCallInfo_element_pdu_element* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element);
+
+         stat = asn1PD_H225InfoRequestResponse_perCallInfo_element_pdu_element (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse_perCallInfo_element                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.originatorPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.audioPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.videoPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.dataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode callReferenceValue */
+
+   invokeStartElement (pctxt, "callReferenceValue", -1);
+
+   stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callReferenceValue", -1);
+
+   /* decode conferenceID */
+
+   invokeStartElement (pctxt, "conferenceID", -1);
+
+   stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceID", -1);
+
+   /* decode originator */
+
+   if (pvalue->m.originatorPresent) {
+      invokeStartElement (pctxt, "originator", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->originator);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->originator);
+
+      invokeEndElement (pctxt, "originator", -1);
+   }
+
+   /* decode audio */
+
+   if (pvalue->m.audioPresent) {
+      invokeStartElement (pctxt, "audio", -1);
+
+      stat = asn1PD_H225_SeqOfH225RTPSession (pctxt, &pvalue->audio);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "audio", -1);
+   }
+
+   /* decode video */
+
+   if (pvalue->m.videoPresent) {
+      invokeStartElement (pctxt, "video", -1);
+
+      stat = asn1PD_H225_SeqOfH225RTPSession (pctxt, &pvalue->video);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "video", -1);
+   }
+
+   /* decode data */
+
+   if (pvalue->m.dataPresent) {
+      invokeStartElement (pctxt, "data", -1);
+
+      stat = asn1PD_H225_SeqOfH225TransportChannelInfo (pctxt, &pvalue->data);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "data", -1);
+   }
+
+   /* decode h245 */
+
+   invokeStartElement (pctxt, "h245", -1);
+
+   stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->h245);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "h245", -1);
+
+   /* decode callSignaling */
+
+   invokeStartElement (pctxt, "callSignaling", -1);
+
+   stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->callSignaling);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callSignaling", -1);
+
+   /* decode callType */
+
+   invokeStartElement (pctxt, "callType", -1);
+
+   stat = asn1PD_H225CallType (pctxt, &pvalue->callType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callType", -1);
+
+   /* decode bandWidth */
+
+   invokeStartElement (pctxt, "bandWidth", -1);
+
+   stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "bandWidth", -1);
+
+   /* decode callModel */
+
+   invokeStartElement (pctxt, "callModel", -1);
+
+   stat = asn1PD_H225CallModel (pctxt, &pvalue->callModel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callModel", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 8 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.callIdentifierPresent = 1;
+
+                     invokeStartElement (pctxt, "callIdentifier", -1);
+
+                     stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callIdentifier", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.substituteConfIDsPresent = 1;
+
+                     invokeStartElement (pctxt, "substituteConfIDs", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ConferenceIdentifier (pctxt, &pvalue->substituteConfIDs);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "substituteConfIDs", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.pduPresent = 1;
+
+                     invokeStartElement (pctxt, "pdu", -1);
+
+                     stat = asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (pctxt, &pvalue->pdu);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "pdu", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.callLinkagePresent = 1;
+
+                     invokeStartElement (pctxt, "callLinkage", -1);
+
+                     stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "callLinkage", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.usageInformationPresent = 1;
+
+                     invokeStartElement (pctxt, "usageInformation", -1);
+
+                     stat = asn1PD_H225RasUsageInformation (pctxt, &pvalue->usageInformation);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "usageInformation", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.circuitInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "circuitInfo", -1);
+
+                     stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "circuitInfo", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225InfoRequestResponse_perCallInfo_element         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element* pvalue)
+{
+   int stat = ASN_OK;
+   H225InfoRequestResponse_perCallInfo_element* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225InfoRequestResponse_perCallInfo_element);
+
+         stat = asn1PD_H225InfoRequestResponse_perCallInfo_element (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponseStatus                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225InfoRequestResponseStatus (OOCTXT* pctxt, H225InfoRequestResponseStatus* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* complete */
+         case 0:
+            invokeStartElement (pctxt, "complete", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "complete", -1);
+
+            break;
+
+         /* incomplete */
+         case 1:
+            invokeStartElement (pctxt, "incomplete", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "incomplete", -1);
+
+            break;
+
+         /* segment */
+         case 2:
+            invokeStartElement (pctxt, "segment", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.segment, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.segment);
+
+            invokeEndElement (pctxt, "segment", -1);
+
+            break;
+
+         /* invalidCall */
+         case 3:
+            invokeStartElement (pctxt, "invalidCall", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidCall", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225InfoRequestResponse (OOCTXT* pctxt, H225InfoRequestResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endpointAliasPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.perCallInfoPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode endpointType */
+
+   invokeStartElement (pctxt, "endpointType", -1);
+
+   stat = asn1PD_H225EndpointType (pctxt, &pvalue->endpointType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointType", -1);
+
+   /* decode endpointIdentifier */
+
+   invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+   stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointIdentifier", -1);
+
+   /* decode rasAddress */
+
+   invokeStartElement (pctxt, "rasAddress", -1);
+
+   stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rasAddress", -1);
+
+   /* decode callSignalAddress */
+
+   invokeStartElement (pctxt, "callSignalAddress", -1);
+
+   stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callSignalAddress", -1);
+
+   /* decode endpointAlias */
+
+   if (pvalue->m.endpointAliasPresent) {
+      invokeStartElement (pctxt, "endpointAlias", -1);
+
+      stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "endpointAlias", -1);
+   }
+
+   /* decode perCallInfo */
+
+   if (pvalue->m.perCallInfoPresent) {
+      invokeStartElement (pctxt, "perCallInfo", -1);
+
+      stat = asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (pctxt, &pvalue->perCallInfo);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "perCallInfo", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 8 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.needResponsePresent = 1;
+
+                     invokeStartElement (pctxt, "needResponse", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->needResponse);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->needResponse);
+
+                     invokeEndElement (pctxt, "needResponse", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.irrStatusPresent = 1;
+
+                     invokeStartElement (pctxt, "irrStatus", -1);
+
+                     stat = asn1PD_H225InfoRequestResponseStatus (pctxt, &pvalue->irrStatus);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "irrStatus", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.unsolicitedPresent = 1;
+
+                     invokeStartElement (pctxt, "unsolicited", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->unsolicited);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->unsolicited);
+
+                     invokeEndElement (pctxt, "unsolicited", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardMessage                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225NonStandardMessage (OOCTXT* pctxt, H225NonStandardMessage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode nonStandardData */
+
+   invokeStartElement (pctxt, "nonStandardData", -1);
+
+   stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nonStandardData", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 5 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.featureSetPresent = 1;
+
+                     invokeStartElement (pctxt, "featureSet", -1);
+
+                     stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "featureSet", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnknownMessageResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225UnknownMessageResponse (OOCTXT* pctxt, H225UnknownMessageResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 4 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.tokensPresent = 1;
+
+                     invokeStartElement (pctxt, "tokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "tokens", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.cryptoTokensPresent = 1;
+
+                     invokeStartElement (pctxt, "cryptoTokens", -1);
+
+                     stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "cryptoTokens", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.integrityCheckValuePresent = 1;
+
+                     invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+                     stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "integrityCheckValue", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.messageNotUnderstoodPresent = 1;
+
+                     invokeStartElement (pctxt, "messageNotUnderstood", -1);
+
+                     stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->messageNotUnderstood);
+                     if (stat != ASN_OK) return stat;
+                     invokeOctStrValue (pctxt, pvalue->messageNotUnderstood.numocts, pvalue->messageNotUnderstood.data);
+
+                     invokeEndElement (pctxt, "messageNotUnderstood", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestInProgress                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RequestInProgress (OOCTXT* pctxt, H225RequestInProgress* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.integrityCheckValuePresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+      stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "integrityCheckValue", -1);
+   }
+
+   /* decode delay */
+
+   invokeStartElement (pctxt, "delay", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->delay, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->delay);
+
+   invokeEndElement (pctxt, "delay", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ResourcesAvailableIndicate                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ResourcesAvailableIndicate (OOCTXT* pctxt, H225ResourcesAvailableIndicate* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.integrityCheckValuePresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode endpointIdentifier */
+
+   invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+   stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "endpointIdentifier", -1);
+
+   /* decode protocols */
+
+   invokeStartElement (pctxt, "protocols", -1);
+
+   stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocols);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocols", -1);
+
+   /* decode almostOutOfResources */
+
+   invokeStartElement (pctxt, "almostOutOfResources", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->almostOutOfResources);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->almostOutOfResources);
+
+   invokeEndElement (pctxt, "almostOutOfResources", -1);
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+      stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "integrityCheckValue", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.capacityPresent = 1;
+
+                     invokeStartElement (pctxt, "capacity", -1);
+
+                     stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "capacity", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ResourcesAvailableConfirm                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ResourcesAvailableConfirm (OOCTXT* pctxt, H225ResourcesAvailableConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.integrityCheckValuePresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+      stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "integrityCheckValue", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.genericDataPresent = 1;
+
+                     invokeStartElement (pctxt, "genericData", -1);
+
+                     stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericData", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestAck                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225InfoRequestAck (OOCTXT* pctxt, H225InfoRequestAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.integrityCheckValuePresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+      stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "integrityCheckValue", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestNakReason                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225InfoRequestNakReason (OOCTXT* pctxt, H225InfoRequestNakReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* notRegistered */
+         case 0:
+            invokeStartElement (pctxt, "notRegistered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "notRegistered", -1);
+
+            break;
+
+         /* securityDenial */
+         case 1:
+            invokeStartElement (pctxt, "securityDenial", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "securityDenial", -1);
+
+            break;
+
+         /* undefinedReason */
+         case 2:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* securityError */
+         case 4:
+            invokeStartElement (pctxt, "securityError", -1);
+
+            pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
+
+            stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "securityError", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestNak                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225InfoRequestNak (OOCTXT* pctxt, H225InfoRequestNak* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.altGKInfoPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.integrityCheckValuePresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode nakReason */
+
+   invokeStartElement (pctxt, "nakReason", -1);
+
+   stat = asn1PD_H225InfoRequestNakReason (pctxt, &pvalue->nakReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nakReason", -1);
+
+   /* decode altGKInfo */
+
+   if (pvalue->m.altGKInfoPresent) {
+      invokeStartElement (pctxt, "altGKInfo", -1);
+
+      stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "altGKInfo", -1);
+   }
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+      stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "integrityCheckValue", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlIndication_callSpecific                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ServiceControlIndication_callSpecific (OOCTXT* pctxt, H225ServiceControlIndication_callSpecific* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode callIdentifier */
+
+   invokeStartElement (pctxt, "callIdentifier", -1);
+
+   stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "callIdentifier", -1);
+
+   /* decode conferenceID */
+
+   invokeStartElement (pctxt, "conferenceID", -1);
+
+   stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceID", -1);
+
+   /* decode answeredCall */
+
+   invokeStartElement (pctxt, "answeredCall", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->answeredCall);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->answeredCall);
+
+   invokeEndElement (pctxt, "answeredCall", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlIndication                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ServiceControlIndication (OOCTXT* pctxt, H225ServiceControlIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.endpointIdentifierPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.callSpecificPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.integrityCheckValuePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.featureSetPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.genericDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode serviceControl */
+
+   invokeStartElement (pctxt, "serviceControl", -1);
+
+   stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "serviceControl", -1);
+
+   /* decode endpointIdentifier */
+
+   if (pvalue->m.endpointIdentifierPresent) {
+      invokeStartElement (pctxt, "endpointIdentifier", -1);
+
+      stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "endpointIdentifier", -1);
+   }
+
+   /* decode callSpecific */
+
+   if (pvalue->m.callSpecificPresent) {
+      invokeStartElement (pctxt, "callSpecific", -1);
+
+      stat = asn1PD_H225ServiceControlIndication_callSpecific (pctxt, &pvalue->callSpecific);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "callSpecific", -1);
+   }
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+      stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "integrityCheckValue", -1);
+   }
+
+   /* decode featureSet */
+
+   if (pvalue->m.featureSetPresent) {
+      invokeStartElement (pctxt, "featureSet", -1);
+
+      stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "featureSet", -1);
+   }
+
+   /* decode genericData */
+
+   if (pvalue->m.genericDataPresent) {
+      invokeStartElement (pctxt, "genericData", -1);
+
+      stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "genericData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlResponse_result                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ServiceControlResponse_result (OOCTXT* pctxt, H225ServiceControlResponse_result* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* started */
+         case 0:
+            invokeStartElement (pctxt, "started", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "started", -1);
+
+            break;
+
+         /* failed */
+         case 1:
+            invokeStartElement (pctxt, "failed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "failed", -1);
+
+            break;
+
+         /* stopped */
+         case 2:
+            invokeStartElement (pctxt, "stopped", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "stopped", -1);
+
+            break;
+
+         /* notAvailable */
+         case 3:
+            invokeStartElement (pctxt, "notAvailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "notAvailable", -1);
+
+            break;
+
+         /* neededFeatureNotSupported */
+         case 4:
+            invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225ServiceControlResponse (OOCTXT* pctxt, H225ServiceControlResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.resultPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cryptoTokensPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.integrityCheckValuePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.featureSetPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.genericDataPresent = optbit;
+
+   /* decode requestSeqNum */
+
+   invokeStartElement (pctxt, "requestSeqNum", -1);
+
+   stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestSeqNum", -1);
+
+   /* decode result */
+
+   if (pvalue->m.resultPresent) {
+      invokeStartElement (pctxt, "result", -1);
+
+      stat = asn1PD_H225ServiceControlResponse_result (pctxt, &pvalue->result);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "result", -1);
+   }
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      invokeStartElement (pctxt, "tokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "tokens", -1);
+   }
+
+   /* decode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      invokeStartElement (pctxt, "cryptoTokens", -1);
+
+      stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "cryptoTokens", -1);
+   }
+
+   /* decode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      invokeStartElement (pctxt, "integrityCheckValue", -1);
+
+      stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "integrityCheckValue", -1);
+   }
+
+   /* decode featureSet */
+
+   if (pvalue->m.featureSetPresent) {
+      invokeStartElement (pctxt, "featureSet", -1);
+
+      stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "featureSet", -1);
+   }
+
+   /* decode genericData */
+
+   if (pvalue->m.genericDataPresent) {
+      invokeStartElement (pctxt, "genericData", -1);
+
+      stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "genericData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AdmissionConfirm                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225_SeqOfH225AdmissionConfirm (OOCTXT* pctxt, H225_SeqOfH225AdmissionConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   H225AdmissionConfirm* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AdmissionConfirm);
+
+         stat = asn1PD_H225AdmissionConfirm (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasMessage                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H225RasMessage (OOCTXT* pctxt, H225RasMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 24);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* gatekeeperRequest */
+         case 0:
+            invokeStartElement (pctxt, "gatekeeperRequest", -1);
+
+            pvalue->u.gatekeeperRequest = ALLOC_ASN1ELEM (pctxt, H225GatekeeperRequest);
+
+            stat = asn1PD_H225GatekeeperRequest (pctxt, pvalue->u.gatekeeperRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gatekeeperRequest", -1);
+
+            break;
+
+         /* gatekeeperConfirm */
+         case 1:
+            invokeStartElement (pctxt, "gatekeeperConfirm", -1);
+
+            pvalue->u.gatekeeperConfirm = ALLOC_ASN1ELEM (pctxt, H225GatekeeperConfirm);
+
+            stat = asn1PD_H225GatekeeperConfirm (pctxt, pvalue->u.gatekeeperConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gatekeeperConfirm", -1);
+
+            break;
+
+         /* gatekeeperReject */
+         case 2:
+            invokeStartElement (pctxt, "gatekeeperReject", -1);
+
+            pvalue->u.gatekeeperReject = ALLOC_ASN1ELEM (pctxt, H225GatekeeperReject);
+
+            stat = asn1PD_H225GatekeeperReject (pctxt, pvalue->u.gatekeeperReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gatekeeperReject", -1);
+
+            break;
+
+         /* registrationRequest */
+         case 3:
+            invokeStartElement (pctxt, "registrationRequest", -1);
+
+            pvalue->u.registrationRequest = ALLOC_ASN1ELEM (pctxt, H225RegistrationRequest);
+
+            stat = asn1PD_H225RegistrationRequest (pctxt, pvalue->u.registrationRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "registrationRequest", -1);
+
+            break;
+
+         /* registrationConfirm */
+         case 4:
+            invokeStartElement (pctxt, "registrationConfirm", -1);
+
+            pvalue->u.registrationConfirm = ALLOC_ASN1ELEM (pctxt, H225RegistrationConfirm);
+
+            stat = asn1PD_H225RegistrationConfirm (pctxt, pvalue->u.registrationConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "registrationConfirm", -1);
+
+            break;
+
+         /* registrationReject */
+         case 5:
+            invokeStartElement (pctxt, "registrationReject", -1);
+
+            pvalue->u.registrationReject = ALLOC_ASN1ELEM (pctxt, H225RegistrationReject);
+
+            stat = asn1PD_H225RegistrationReject (pctxt, pvalue->u.registrationReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "registrationReject", -1);
+
+            break;
+
+         /* unregistrationRequest */
+         case 6:
+            invokeStartElement (pctxt, "unregistrationRequest", -1);
+
+            pvalue->u.unregistrationRequest = ALLOC_ASN1ELEM (pctxt, H225UnregistrationRequest);
+
+            stat = asn1PD_H225UnregistrationRequest (pctxt, pvalue->u.unregistrationRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "unregistrationRequest", -1);
+
+            break;
+
+         /* unregistrationConfirm */
+         case 7:
+            invokeStartElement (pctxt, "unregistrationConfirm", -1);
+
+            pvalue->u.unregistrationConfirm = ALLOC_ASN1ELEM (pctxt, H225UnregistrationConfirm);
+
+            stat = asn1PD_H225UnregistrationConfirm (pctxt, pvalue->u.unregistrationConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "unregistrationConfirm", -1);
+
+            break;
+
+         /* unregistrationReject */
+         case 8:
+            invokeStartElement (pctxt, "unregistrationReject", -1);
+
+            pvalue->u.unregistrationReject = ALLOC_ASN1ELEM (pctxt, H225UnregistrationReject);
+
+            stat = asn1PD_H225UnregistrationReject (pctxt, pvalue->u.unregistrationReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "unregistrationReject", -1);
+
+            break;
+
+         /* admissionRequest */
+         case 9:
+            invokeStartElement (pctxt, "admissionRequest", -1);
+
+            pvalue->u.admissionRequest = ALLOC_ASN1ELEM (pctxt, H225AdmissionRequest);
+
+            stat = asn1PD_H225AdmissionRequest (pctxt, pvalue->u.admissionRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "admissionRequest", -1);
+
+            break;
+
+         /* admissionConfirm */
+         case 10:
+            invokeStartElement (pctxt, "admissionConfirm", -1);
+
+            pvalue->u.admissionConfirm = ALLOC_ASN1ELEM (pctxt, H225AdmissionConfirm);
+
+            stat = asn1PD_H225AdmissionConfirm (pctxt, pvalue->u.admissionConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "admissionConfirm", -1);
+
+            break;
+
+         /* admissionReject */
+         case 11:
+            invokeStartElement (pctxt, "admissionReject", -1);
+
+            pvalue->u.admissionReject = ALLOC_ASN1ELEM (pctxt, H225AdmissionReject);
+
+            stat = asn1PD_H225AdmissionReject (pctxt, pvalue->u.admissionReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "admissionReject", -1);
+
+            break;
+
+         /* bandwidthRequest */
+         case 12:
+            invokeStartElement (pctxt, "bandwidthRequest", -1);
+
+            pvalue->u.bandwidthRequest = ALLOC_ASN1ELEM (pctxt, H225BandwidthRequest);
+
+            stat = asn1PD_H225BandwidthRequest (pctxt, pvalue->u.bandwidthRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "bandwidthRequest", -1);
+
+            break;
+
+         /* bandwidthConfirm */
+         case 13:
+            invokeStartElement (pctxt, "bandwidthConfirm", -1);
+
+            pvalue->u.bandwidthConfirm = ALLOC_ASN1ELEM (pctxt, H225BandwidthConfirm);
+
+            stat = asn1PD_H225BandwidthConfirm (pctxt, pvalue->u.bandwidthConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "bandwidthConfirm", -1);
+
+            break;
+
+         /* bandwidthReject */
+         case 14:
+            invokeStartElement (pctxt, "bandwidthReject", -1);
+
+            pvalue->u.bandwidthReject = ALLOC_ASN1ELEM (pctxt, H225BandwidthReject);
+
+            stat = asn1PD_H225BandwidthReject (pctxt, pvalue->u.bandwidthReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "bandwidthReject", -1);
+
+            break;
+
+         /* disengageRequest */
+         case 15:
+            invokeStartElement (pctxt, "disengageRequest", -1);
+
+            pvalue->u.disengageRequest = ALLOC_ASN1ELEM (pctxt, H225DisengageRequest);
+
+            stat = asn1PD_H225DisengageRequest (pctxt, pvalue->u.disengageRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "disengageRequest", -1);
+
+            break;
+
+         /* disengageConfirm */
+         case 16:
+            invokeStartElement (pctxt, "disengageConfirm", -1);
+
+            pvalue->u.disengageConfirm = ALLOC_ASN1ELEM (pctxt, H225DisengageConfirm);
+
+            stat = asn1PD_H225DisengageConfirm (pctxt, pvalue->u.disengageConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "disengageConfirm", -1);
+
+            break;
+
+         /* disengageReject */
+         case 17:
+            invokeStartElement (pctxt, "disengageReject", -1);
+
+            pvalue->u.disengageReject = ALLOC_ASN1ELEM (pctxt, H225DisengageReject);
+
+            stat = asn1PD_H225DisengageReject (pctxt, pvalue->u.disengageReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "disengageReject", -1);
+
+            break;
+
+         /* locationRequest */
+         case 18:
+            invokeStartElement (pctxt, "locationRequest", -1);
+
+            pvalue->u.locationRequest = ALLOC_ASN1ELEM (pctxt, H225LocationRequest);
+
+            stat = asn1PD_H225LocationRequest (pctxt, pvalue->u.locationRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "locationRequest", -1);
+
+            break;
+
+         /* locationConfirm */
+         case 19:
+            invokeStartElement (pctxt, "locationConfirm", -1);
+
+            pvalue->u.locationConfirm = ALLOC_ASN1ELEM (pctxt, H225LocationConfirm);
+
+            stat = asn1PD_H225LocationConfirm (pctxt, pvalue->u.locationConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "locationConfirm", -1);
+
+            break;
+
+         /* locationReject */
+         case 20:
+            invokeStartElement (pctxt, "locationReject", -1);
+
+            pvalue->u.locationReject = ALLOC_ASN1ELEM (pctxt, H225LocationReject);
+
+            stat = asn1PD_H225LocationReject (pctxt, pvalue->u.locationReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "locationReject", -1);
+
+            break;
+
+         /* infoRequest */
+         case 21:
+            invokeStartElement (pctxt, "infoRequest", -1);
+
+            pvalue->u.infoRequest = ALLOC_ASN1ELEM (pctxt, H225InfoRequest);
+
+            stat = asn1PD_H225InfoRequest (pctxt, pvalue->u.infoRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "infoRequest", -1);
+
+            break;
+
+         /* infoRequestResponse */
+         case 22:
+            invokeStartElement (pctxt, "infoRequestResponse", -1);
+
+            pvalue->u.infoRequestResponse = ALLOC_ASN1ELEM (pctxt, H225InfoRequestResponse);
+
+            stat = asn1PD_H225InfoRequestResponse (pctxt, pvalue->u.infoRequestResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "infoRequestResponse", -1);
+
+            break;
+
+         /* nonStandardMessage */
+         case 23:
+            invokeStartElement (pctxt, "nonStandardMessage", -1);
+
+            pvalue->u.nonStandardMessage = ALLOC_ASN1ELEM (pctxt, H225NonStandardMessage);
+
+            stat = asn1PD_H225NonStandardMessage (pctxt, pvalue->u.nonStandardMessage);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandardMessage", -1);
+
+            break;
+
+         /* unknownMessageResponse */
+         case 24:
+            invokeStartElement (pctxt, "unknownMessageResponse", -1);
+
+            pvalue->u.unknownMessageResponse = ALLOC_ASN1ELEM (pctxt, H225UnknownMessageResponse);
+
+            stat = asn1PD_H225UnknownMessageResponse (pctxt, pvalue->u.unknownMessageResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "unknownMessageResponse", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 26;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* requestInProgress */
+         case 26:
+            invokeStartElement (pctxt, "requestInProgress", -1);
+
+            pvalue->u.requestInProgress = ALLOC_ASN1ELEM (pctxt, H225RequestInProgress);
+
+            stat = asn1PD_H225RequestInProgress (pctxt, pvalue->u.requestInProgress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestInProgress", -1);
+
+            break;
+
+         /* resourcesAvailableIndicate */
+         case 27:
+            invokeStartElement (pctxt, "resourcesAvailableIndicate", -1);
+
+            pvalue->u.resourcesAvailableIndicate = ALLOC_ASN1ELEM (pctxt, H225ResourcesAvailableIndicate);
+
+            stat = asn1PD_H225ResourcesAvailableIndicate (pctxt, pvalue->u.resourcesAvailableIndicate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "resourcesAvailableIndicate", -1);
+
+            break;
+
+         /* resourcesAvailableConfirm */
+         case 28:
+            invokeStartElement (pctxt, "resourcesAvailableConfirm", -1);
+
+            pvalue->u.resourcesAvailableConfirm = ALLOC_ASN1ELEM (pctxt, H225ResourcesAvailableConfirm);
+
+            stat = asn1PD_H225ResourcesAvailableConfirm (pctxt, pvalue->u.resourcesAvailableConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "resourcesAvailableConfirm", -1);
+
+            break;
+
+         /* infoRequestAck */
+         case 29:
+            invokeStartElement (pctxt, "infoRequestAck", -1);
+
+            pvalue->u.infoRequestAck = ALLOC_ASN1ELEM (pctxt, H225InfoRequestAck);
+
+            stat = asn1PD_H225InfoRequestAck (pctxt, pvalue->u.infoRequestAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "infoRequestAck", -1);
+
+            break;
+
+         /* infoRequestNak */
+         case 30:
+            invokeStartElement (pctxt, "infoRequestNak", -1);
+
+            pvalue->u.infoRequestNak = ALLOC_ASN1ELEM (pctxt, H225InfoRequestNak);
+
+            stat = asn1PD_H225InfoRequestNak (pctxt, pvalue->u.infoRequestNak);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "infoRequestNak", -1);
+
+            break;
+
+         /* serviceControlIndication */
+         case 31:
+            invokeStartElement (pctxt, "serviceControlIndication", -1);
+
+            pvalue->u.serviceControlIndication = ALLOC_ASN1ELEM (pctxt, H225ServiceControlIndication);
+
+            stat = asn1PD_H225ServiceControlIndication (pctxt, pvalue->u.serviceControlIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "serviceControlIndication", -1);
+
+            break;
+
+         /* serviceControlResponse */
+         case 32:
+            invokeStartElement (pctxt, "serviceControlResponse", -1);
+
+            pvalue->u.serviceControlResponse = ALLOC_ASN1ELEM (pctxt, H225ServiceControlResponse);
+
+            stat = asn1PD_H225ServiceControlResponse (pctxt, pvalue->u.serviceControlResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "serviceControlResponse", -1);
+
+            break;
+
+         /* admissionConfirmSequence */
+         case 33:
+            invokeStartElement (pctxt, "admissionConfirmSequence", -1);
+
+            pvalue->u.admissionConfirmSequence = ALLOC_ASN1ELEM (pctxt, H225_SeqOfH225AdmissionConfirm);
+
+            stat = asn1PD_H225_SeqOfH225AdmissionConfirm (pctxt, pvalue->u.admissionConfirmSequence);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "admissionConfirmSequence", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
diff --git a/addons/ooh323c/src/h323/H323-MESSAGESEnc.c b/addons/ooh323c/src/h323/H323-MESSAGESEnc.c
new file mode 100644
index 000000000..62a2cd006
--- /dev/null
+++ b/addons/ooh323c/src/h323/H323-MESSAGESEnc.c
@@ -0,0 +1,22596 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#include "ooasn1.h"
+#include "H323-MESSAGES.h"
+
+/**************************************************************/
+/*                                                            */
+/*  ScreeningIndicator                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator value)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1BOOL extbit;
+
+   extbit = 0;
+
+   switch (value) {
+      case userProvidedNotScreened: ui = 0; break;
+      case userProvidedVerifiedAndPassed: ui = 1; break;
+      case userProvidedVerifiedAndFailed: ui = 2; break;
+      case networkProvided: ui = 3; break;
+      default: ui = value; extbit = 1;
+   }
+
+   /* extension bit */
+
+   encodeBit (pctxt, extbit);
+
+   if (extbit) {
+      stat = encodeSmallNonNegWholeNumber (pctxt, ui);
+   }
+   else {
+      stat = encodeConsUnsigned (pctxt, ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NumberDigits                                              */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_NumberDigits_CharSet;
+
+EXTERN int asn1PE_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits value)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeConstrainedStringEx (pctxt, value, gs_H323_MESSAGES_NumberDigits_CharSet, 4, 4, 7);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TBCD_STRING                                               */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_TBCD_STRING_CharSet;
+
+EXTERN int asn1PE_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConstrainedStringEx (pctxt, value, gs_H323_MESSAGES_TBCD_STRING_CharSet, 4, 4, 7);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GloballyUniqueID                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = asn1PE_H225GloballyUniqueID (pctxt, pvalue);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestSeqNum                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier value)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBMPString (pctxt, value, 0);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandWidth                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225BandWidth (OOCTXT* pctxt, H225BandWidth value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallReferenceValue                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointIdentifier                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier value)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBMPString (pctxt, value, 0);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ProtocolIdentifier                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeObjectIdentifier (pctxt, &value);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TimeToLive                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 1U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H248PackagesDescriptor                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeOctetString (pctxt, value.numocts, value.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H248SignalsDescriptor                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeOctetString (pctxt, value.numocts, value.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericIdentifier                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* standard */
+         case 1:
+            if ( (pvalue->u.standard >= 0 && pvalue->u.standard <= 16383) ) {
+               extbit = 0;
+            }
+            else extbit = 1;
+
+            /* extension bit */
+
+            encodeBit (pctxt, extbit);
+
+            if (extbit) {
+               stat = encodeUnconsInteger (pctxt, pvalue->u.standard);
+               if (stat != ASN_OK) return stat;
+            }
+            else {
+               stat = encodeConsInteger (pctxt, pvalue->u.standard, 0, 16383);
+               if (stat != ASN_OK) return stat;
+            }
+            break;
+
+         /* oid */
+         case 2:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.oid);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nonStandard */
+         case 3:
+            stat = asn1PE_H225GloballyUniqueID (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipAddress_ip                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipAddress                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode ip */
+
+   stat = asn1PE_H225TransportAddress_ipAddress_ip (pctxt, &pvalue->ip);
+   if (stat != ASN_OK) return stat;
+
+   /* encode port */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_ip                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_route_element              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportAddress_ipSourceRoute_route_element    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute_routing                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* strict */
+         case 1:
+            /* NULL */
+            break;
+
+         /* loose */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipSourceRoute                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode ip */
+
+   stat = asn1PE_H225TransportAddress_ipSourceRoute_ip (pctxt, &pvalue->ip);
+   if (stat != ASN_OK) return stat;
+
+   /* encode port */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode route */
+
+   stat = asn1PE_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->route);
+   if (stat != ASN_OK) return stat;
+
+   /* encode routing */
+
+   stat = asn1PE_H225TransportAddress_ipSourceRoute_routing (pctxt, &pvalue->routing);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_node                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_netnum                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress_port                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ipxAddress                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode node */
+
+   stat = asn1PE_H225TransportAddress_ipxAddress_node (pctxt, &pvalue->node);
+   if (stat != ASN_OK) return stat;
+
+   /* encode netnum */
+
+   stat = asn1PE_H225TransportAddress_ipxAddress_netnum (pctxt, &pvalue->netnum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode port */
+
+   stat = asn1PE_H225TransportAddress_ipxAddress_port (pctxt, &pvalue->port);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ip6Address_ip                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_ip6Address                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode ip */
+
+   stat = asn1PE_H225TransportAddress_ip6Address_ip (pctxt, &pvalue->ip);
+   if (stat != ASN_OK) return stat;
+
+   /* encode port */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_netBios                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress_nsap                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H221NonStandard                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode t35CountryCode */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t35CountryCode, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode t35Extension */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t35Extension, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode manufacturerCode */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->manufacturerCode, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* object */
+         case 1:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.object);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h221NonStandard */
+         case 2:
+            stat = asn1PE_H225H221NonStandard (pctxt, pvalue->u.h221NonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode nonStandardIdentifier */
+
+   stat = asn1PE_H225NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode data */
+
+   stat = encodeOctetString (pctxt, pvalue->data.numocts, pvalue->data.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 7);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* ipAddress */
+         case 1:
+            stat = asn1PE_H225TransportAddress_ipAddress (pctxt, pvalue->u.ipAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* ipSourceRoute */
+         case 2:
+            stat = asn1PE_H225TransportAddress_ipSourceRoute (pctxt, pvalue->u.ipSourceRoute);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* ipxAddress */
+         case 3:
+            stat = asn1PE_H225TransportAddress_ipxAddress (pctxt, pvalue->u.ipxAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* ip6Address */
+         case 4:
+            stat = asn1PE_H225TransportAddress_ip6Address (pctxt, pvalue->u.ip6Address);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* netBios */
+         case 5:
+            stat = asn1PE_H225TransportAddress_netBios (pctxt, pvalue->u.netBios);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nsap */
+         case 6:
+            stat = asn1PE_H225TransportAddress_nsap (pctxt, pvalue->u.nsap);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nonStandardAddress */
+         case 7:
+            stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandardAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PublicTypeOfNumber                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unknown */
+         case 1:
+            /* NULL */
+            break;
+
+         /* internationalNumber */
+         case 2:
+            /* NULL */
+            break;
+
+         /* nationalNumber */
+         case 3:
+            /* NULL */
+            break;
+
+         /* networkSpecificNumber */
+         case 4:
+            /* NULL */
+            break;
+
+         /* subscriberNumber */
+         case 5:
+            /* NULL */
+            break;
+
+         /* abbreviatedNumber */
+         case 6:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PublicPartyNumber                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode publicTypeOfNumber */
+
+   stat = asn1PE_H225PublicTypeOfNumber (pctxt, &pvalue->publicTypeOfNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode publicNumberDigits */
+
+   stat = asn1PE_H225NumberDigits (pctxt, pvalue->publicNumberDigits);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PrivateTypeOfNumber                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unknown */
+         case 1:
+            /* NULL */
+            break;
+
+         /* level2RegionalNumber */
+         case 2:
+            /* NULL */
+            break;
+
+         /* level1RegionalNumber */
+         case 3:
+            /* NULL */
+            break;
+
+         /* pISNSpecificNumber */
+         case 4:
+            /* NULL */
+            break;
+
+         /* localNumber */
+         case 5:
+            /* NULL */
+            break;
+
+         /* abbreviatedNumber */
+         case 6:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PrivatePartyNumber                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode privateTypeOfNumber */
+
+   stat = asn1PE_H225PrivateTypeOfNumber (pctxt, &pvalue->privateTypeOfNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode privateNumberDigits */
+
+   stat = asn1PE_H225NumberDigits (pctxt, pvalue->privateNumberDigits);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PartyNumber                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* e164Number */
+         case 1:
+            stat = asn1PE_H225PublicPartyNumber (pctxt, pvalue->u.e164Number);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* dataPartyNumber */
+         case 2:
+            stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.dataPartyNumber);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* telexPartyNumber */
+         case 3:
+            stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.telexPartyNumber);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* privateNumber */
+         case 4:
+            stat = asn1PE_H225PrivatePartyNumber (pctxt, pvalue->u.privateNumber);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nationalStandardPartyNumber */
+         case 5:
+            stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.nationalStandardPartyNumber);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_system_id                                     */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet;
+
+EXTERN int asn1PE_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue)
+{
+   static Asn1SizeCnst sid_lsize1 = { 0, 1, 4, 0 };
+   static Asn1SizeCnst mid_lsize1 = { 0, 1, 4, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* sid */
+         case 1:
+            addSizeConstraint (pctxt, &sid_lsize1);
+
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.sid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet, 4, 4, 7);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* mid */
+         case 2:
+            addSizeConstraint (pctxt, &mid_lsize1);
+
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.mid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet, 4, 4, 7);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_systemMyTypeCode                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_systemAccessType                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM_qualificationInformationCode                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ANSI_41_UIM                                               */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet;
+
+EXTERN int asn1PE_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue)
+{
+   static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst min_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst mdn_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst esn_lsize1 = { 0, 16, 16, 0 };
+   static Asn1SizeCnst mscid_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst sesn_lsize1 = { 0, 16, 16, 0 };
+   static Asn1SizeCnst soc_lsize1 = { 0, 3, 16, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.imsiPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.minPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mdnPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.msisdnPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.esnPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mscidPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.systemMyTypeCodePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.systemAccessTypePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.qualificationInformationCodePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sesnPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.socPresent);
+
+   /* encode imsi */
+
+   if (pvalue->m.imsiPresent) {
+      addSizeConstraint (pctxt, &imsi_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->imsi, gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode min */
+
+   if (pvalue->m.minPresent) {
+      addSizeConstraint (pctxt, &min_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->min, gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mdn */
+
+   if (pvalue->m.mdnPresent) {
+      addSizeConstraint (pctxt, &mdn_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->mdn, gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode msisdn */
+
+   if (pvalue->m.msisdnPresent) {
+      addSizeConstraint (pctxt, &msisdn_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->msisdn, gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode esn */
+
+   if (pvalue->m.esnPresent) {
+      addSizeConstraint (pctxt, &esn_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->esn, gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mscid */
+
+   if (pvalue->m.mscidPresent) {
+      addSizeConstraint (pctxt, &mscid_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->mscid, gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode system_id */
+
+   stat = asn1PE_H225ANSI_41_UIM_system_id (pctxt, &pvalue->system_id);
+   if (stat != ASN_OK) return stat;
+
+   /* encode systemMyTypeCode */
+
+   if (pvalue->m.systemMyTypeCodePresent) {
+      stat = asn1PE_H225ANSI_41_UIM_systemMyTypeCode (pctxt, &pvalue->systemMyTypeCode);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode systemAccessType */
+
+   if (pvalue->m.systemAccessTypePresent) {
+      stat = asn1PE_H225ANSI_41_UIM_systemAccessType (pctxt, &pvalue->systemAccessType);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode qualificationInformationCode */
+
+   if (pvalue->m.qualificationInformationCodePresent) {
+      stat = asn1PE_H225ANSI_41_UIM_qualificationInformationCode (pctxt, &pvalue->qualificationInformationCode);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode sesn */
+
+   if (pvalue->m.sesnPresent) {
+      addSizeConstraint (pctxt, &sesn_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->sesn, gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode soc */
+
+   if (pvalue->m.socPresent) {
+      addSizeConstraint (pctxt, &soc_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->soc, gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GSM_UIM_tmsi                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GSM_UIM                                                   */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imsi_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imei_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet;
+
+extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet;
+
+EXTERN int asn1PE_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue)
+{
+   static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
+   static Asn1SizeCnst imei_lsize1 = { 0, 15, 16, 0 };
+   static Asn1SizeCnst hplmn_lsize1 = { 0, 1, 4, 0 };
+   static Asn1SizeCnst vplmn_lsize1 = { 0, 1, 4, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.imsiPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tmsiPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.msisdnPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.imeiPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.hplmnPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.vplmnPresent);
+
+   /* encode imsi */
+
+   if (pvalue->m.imsiPresent) {
+      addSizeConstraint (pctxt, &imsi_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->imsi, gs_H323_MESSAGES_GSM_UIM_imsi_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tmsi */
+
+   if (pvalue->m.tmsiPresent) {
+      stat = asn1PE_H225GSM_UIM_tmsi (pctxt, &pvalue->tmsi);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode msisdn */
+
+   if (pvalue->m.msisdnPresent) {
+      addSizeConstraint (pctxt, &msisdn_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->msisdn, gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode imei */
+
+   if (pvalue->m.imeiPresent) {
+      addSizeConstraint (pctxt, &imei_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->imei, gs_H323_MESSAGES_GSM_UIM_imei_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode hplmn */
+
+   if (pvalue->m.hplmnPresent) {
+      addSizeConstraint (pctxt, &hplmn_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->hplmn, gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode vplmn */
+
+   if (pvalue->m.vplmnPresent) {
+      addSizeConstraint (pctxt, &vplmn_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->vplmn, gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet, 4, 4, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MobileUIM                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* ansi_41_uim */
+         case 1:
+            stat = asn1PE_H225ANSI_41_UIM (pctxt, pvalue->u.ansi_41_uim);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* gsm_uim */
+         case 2:
+            stat = asn1PE_H225GSM_UIM (pctxt, pvalue->u.gsm_uim);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AliasAddress                                              */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet;
+
+EXTERN int asn1PE_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue)
+{
+   static Asn1SizeCnst dialedDigits_lsize1 = { 0, 1, 128, 0 };
+   static Asn1SizeCnst h323_ID_lsize1 = { 0, 1, 256, 0 };
+   static Asn1SizeCnst url_ID_lsize1 = { 0, 1, 512, 0 };
+   static Asn1SizeCnst email_ID_lsize1 = { 0, 1, 512, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* dialedDigits */
+         case 1:
+            addSizeConstraint (pctxt, &dialedDigits_lsize1);
+
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.dialedDigits, gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet, 4, 4, 7);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h323_ID */
+         case 2:
+            addSizeConstraint (pctxt, &h323_ID_lsize1);
+
+            stat = encodeBMPString (pctxt, pvalue->u.h323_ID, 0);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* url_ID */
+         case 3:
+            addSizeConstraint (&lctxt, &url_ID_lsize1);
+
+            stat = encodeConstrainedStringEx (&lctxt, pvalue->u.url_ID, 0, 8, 7, 7);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* transportID */
+         case 4:
+            stat = asn1PE_H225TransportAddress (&lctxt, pvalue->u.transportID);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* email_ID */
+         case 5:
+            addSizeConstraint (&lctxt, &email_ID_lsize1);
+
+            stat = encodeConstrainedStringEx (&lctxt, pvalue->u.email_ID, 0, 8, 7, 7);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* partyNumber */
+         case 6:
+            stat = asn1PE_H225PartyNumber (&lctxt, pvalue->u.partyNumber);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* mobileUIM */
+         case 7:
+            stat = asn1PE_H225MobileUIM (&lctxt, pvalue->u.mobileUIM);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Content_compound                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H225EnumeratedParameter (pctxt, (H225EnumeratedParameter*)((H225EnumeratedParameter*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Content_nested                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H225GenericData (pctxt, (H225GenericData*)((H225GenericData*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Content                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Content (OOCTXT* pctxt, H225Content* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 12);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 11);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* raw */
+         case 1:
+            stat = encodeOctetString (pctxt, pvalue->u.raw->numocts, pvalue->u.raw->data);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* text */
+         case 2:
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.text, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* unicode */
+         case 3:
+            stat = encodeBMPString (pctxt, pvalue->u.unicode, 0);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* bool_ */
+         case 4:
+            stat = encodeBit (pctxt, (ASN1BOOL)pvalue->u.bool_);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* number8 */
+         case 5:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.number8, 0U, 255U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* number16 */
+         case 6:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.number16, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* number32 */
+         case 7:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.number32, 0U, ASN1UINT_MAX);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* id */
+         case 8:
+            stat = asn1PE_H225GenericIdentifier (pctxt, pvalue->u.id);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* alias */
+         case 9:
+            stat = asn1PE_H225AliasAddress (pctxt, pvalue->u.alias);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* transport */
+         case 10:
+            stat = asn1PE_H225TransportAddress (pctxt, pvalue->u.transport);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* compound */
+         case 11:
+            stat = asn1PE_H225Content_compound (pctxt, pvalue->u.compound);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nested */
+         case 12:
+            stat = asn1PE_H225Content_nested (pctxt, pvalue->u.nested);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 13);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnumeratedParameter                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.contentPresent);
+
+   /* encode id */
+
+   stat = asn1PE_H225GenericIdentifier (pctxt, &pvalue->id);
+   if (stat != ASN_OK) return stat;
+
+   /* encode content */
+
+   if (pvalue->m.contentPresent) {
+      stat = asn1PE_H225Content (pctxt, &pvalue->content);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericData_parameters                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H225EnumeratedParameter (pctxt, ((H225EnumeratedParameter*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericData                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.parametersPresent);
+
+   /* encode id */
+
+   stat = asn1PE_H225GenericIdentifier (pctxt, &pvalue->id);
+   if (stat != ASN_OK) return stat;
+
+   /* encode parameters */
+
+   if (pvalue->m.parametersPresent) {
+      stat = asn1PE_H225GenericData_parameters (pctxt, &pvalue->parameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FeatureDescriptor                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = asn1PE_H225GenericData (pctxt, pvalue);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FastStartToken                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = asn1PE_H235ClearToken (pctxt, pvalue);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncodedFastStartToken                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeOpenType (pctxt, value.numocts, value.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation_user_data_user_information           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 131, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointType_set                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 32, 32, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier_productId                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier_versionId                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo_cic_element                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo_pointCode                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 5, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CarrierInfo_carrierIdentificationCode                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 3, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallTerminationCause_releaseCompleteCauseIE               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 32, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AliasAddress                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225AliasAddress (pctxt, ((H225AliasAddress*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentifier                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.enterpriseNumberPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.productIdPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.versionIdPresent);
+
+   /* encode vendor */
+
+   stat = asn1PE_H225H221NonStandard (pctxt, &pvalue->vendor);
+   if (stat != ASN_OK) return stat;
+
+   /* encode productId */
+
+   if (pvalue->m.productIdPresent) {
+      stat = asn1PE_H225VendorIdentifier_productId (pctxt, &pvalue->productId);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode versionId */
+
+   if (pvalue->m.versionIdPresent) {
+      stat = asn1PE_H225VendorIdentifier_versionId (pctxt, &pvalue->versionId);
+      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.enterpriseNumberPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.enterpriseNumberPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeObjectIdentifier (&lctxt, &pvalue->enterpriseNumber);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperInfo                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataRate                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.channelMultiplierPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode channelRate */
+
+   stat = asn1PE_H225BandWidth (pctxt, pvalue->channelRate);
+   if (stat != ASN_OK) return stat;
+
+   /* encode channelMultiplier */
+
+   if (pvalue->m.channelMultiplierPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->channelMultiplier, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225DataRate                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225DataRate (pctxt, ((H225DataRate*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SupportedPrefix                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode prefix */
+
+   stat = asn1PE_H225AliasAddress (pctxt, &pvalue->prefix);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225SupportedPrefix                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225SupportedPrefix (pctxt, ((H225SupportedPrefix*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H310Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
+   pvalue->m.supportedPrefixesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.dataRatesSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H320Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
+   pvalue->m.supportedPrefixesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.dataRatesSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H321Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
+   pvalue->m.supportedPrefixesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.dataRatesSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H322Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
+   pvalue->m.supportedPrefixesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.dataRatesSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
+   pvalue->m.supportedPrefixesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.dataRatesSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H324Caps                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
+   pvalue->m.supportedPrefixesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.dataRatesSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VoiceCaps                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
+   pvalue->m.supportedPrefixesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.dataRatesSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T120OnlyCaps                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
+   pvalue->m.supportedPrefixesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.dataRatesSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardProtocol                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode dataRatesSupported */
+
+   if (pvalue->m.dataRatesSupportedPresent) {
+      stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode supportedPrefixes */
+
+   stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxAnnexbOnlyCaps                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode dataRatesSupported */
+
+   if (pvalue->m.dataRatesSupportedPresent) {
+      stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode supportedPrefixes */
+
+   stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+   if (stat != ASN_OK) return stat;
+
+   /* encode t38FaxProtocol */
+
+   stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol);
+   if (stat != ASN_OK) return stat;
+
+   /* encode t38FaxProfile */
+
+   stat = asn1PE_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SIPCaps                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode dataRatesSupported */
+
+   if (pvalue->m.dataRatesSupportedPresent) {
+      stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode supportedPrefixes */
+
+   if (pvalue->m.supportedPrefixesPresent) {
+      stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SupportedProtocols                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 9);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 8);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandardData */
+         case 1:
+            stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandardData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h310 */
+         case 2:
+            stat = asn1PE_H225H310Caps (pctxt, pvalue->u.h310);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h320 */
+         case 3:
+            stat = asn1PE_H225H320Caps (pctxt, pvalue->u.h320);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h321 */
+         case 4:
+            stat = asn1PE_H225H321Caps (pctxt, pvalue->u.h321);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h322 */
+         case 5:
+            stat = asn1PE_H225H322Caps (pctxt, pvalue->u.h322);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h323 */
+         case 6:
+            stat = asn1PE_H225H323Caps (pctxt, pvalue->u.h323);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h324 */
+         case 7:
+            stat = asn1PE_H225H324Caps (pctxt, pvalue->u.h324);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* voice */
+         case 8:
+            stat = asn1PE_H225VoiceCaps (pctxt, pvalue->u.voice);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* t120_only */
+         case 9:
+            stat = asn1PE_H225T120OnlyCaps (pctxt, pvalue->u.t120_only);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 10);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* nonStandardProtocol */
+         case 10:
+            stat = asn1PE_H225NonStandardProtocol (&lctxt, pvalue->u.nonStandardProtocol);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* t38FaxAnnexbOnly */
+         case 11:
+            stat = asn1PE_H225T38FaxAnnexbOnlyCaps (&lctxt, pvalue->u.t38FaxAnnexbOnly);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* sip */
+         case 12:
+            stat = asn1PE_H225SIPCaps (&lctxt, pvalue->u.sip);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225SupportedProtocols                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225SupportedProtocols (pctxt, ((H225SupportedProtocols*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatewayInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.protocolPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode protocol */
+
+   if (pvalue->m.protocolPresent) {
+      stat = asn1PE_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocol);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  McuInfo                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.protocolPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      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.protocolPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.protocolPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->protocol);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalInfo                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocolAlternateIdentifier                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TunnelledProtocolAlternateIdentifier (OOCTXT* pctxt, H225TunnelledProtocolAlternateIdentifier* pvalue)
+{
+   static Asn1SizeCnst protocolType_lsize1 = { 0, 1, 64, 0 };
+   static Asn1SizeCnst protocolVariant_lsize1 = { 0, 1, 64, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.protocolVariantPresent);
+
+   /* encode protocolType */
+
+   addSizeConstraint (pctxt, &protocolType_lsize1);
+
+   stat = encodeConstrainedStringEx (pctxt, pvalue->protocolType, 0, 8, 7, 7);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolVariant */
+
+   if (pvalue->m.protocolVariantPresent) {
+      addSizeConstraint (pctxt, &protocolVariant_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->protocolVariant, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocol_id                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* tunnelledProtocolObjectID */
+         case 1:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.tunnelledProtocolObjectID);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* tunnelledProtocolAlternateID */
+         case 2:
+            stat = asn1PE_H225TunnelledProtocolAlternateIdentifier (pctxt, pvalue->u.tunnelledProtocolAlternateID);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TunnelledProtocol                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TunnelledProtocol (OOCTXT* pctxt, H225TunnelledProtocol* pvalue)
+{
+   static Asn1SizeCnst subIdentifier_lsize1 = { 0, 1, 64, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.subIdentifierPresent);
+
+   /* encode id */
+
+   stat = asn1PE_H225TunnelledProtocol_id (pctxt, &pvalue->id);
+   if (stat != ASN_OK) return stat;
+
+   /* encode subIdentifier */
+
+   if (pvalue->m.subIdentifierPresent) {
+      addSizeConstraint (pctxt, &subIdentifier_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->subIdentifier, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TunnelledProtocol                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225TunnelledProtocol (OOCTXT* pctxt, H225_SeqOfH225TunnelledProtocol* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225TunnelledProtocol (pctxt, ((H225TunnelledProtocol*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndpointType                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225EndpointType (OOCTXT* pctxt, H225EndpointType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.setPresent ||
+   pvalue->m.supportedTunnelledProtocolsPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.vendorPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatewayPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mcuPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode vendor */
+
+   if (pvalue->m.vendorPresent) {
+      stat = asn1PE_H225VendorIdentifier (pctxt, &pvalue->vendor);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode gatekeeper */
+
+   if (pvalue->m.gatekeeperPresent) {
+      stat = asn1PE_H225GatekeeperInfo (pctxt, &pvalue->gatekeeper);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode gateway */
+
+   if (pvalue->m.gatewayPresent) {
+      stat = asn1PE_H225GatewayInfo (pctxt, &pvalue->gateway);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mcu */
+
+   if (pvalue->m.mcuPresent) {
+      stat = asn1PE_H225McuInfo (pctxt, &pvalue->mcu);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode terminal */
+
+   if (pvalue->m.terminalPresent) {
+      stat = asn1PE_H225TerminalInfo (pctxt, &pvalue->terminal);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mc */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mc);
+   if (stat != ASN_OK) return stat;
+
+   /* encode undefinedNode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->undefinedNode);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.setPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedTunnelledProtocolsPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.setPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225EndpointType_set (&lctxt, &pvalue->set);
+         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.supportedTunnelledProtocolsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225TunnelledProtocol (&lctxt, &pvalue->supportedTunnelledProtocols);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CallReferenceValue                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225CallReferenceValue (OOCTXT* pctxt, H225_SeqOfH225CallReferenceValue* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_conferenceGoal                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Setup_UUIE_conferenceGoal (OOCTXT* pctxt, H225Setup_UUIE_conferenceGoal* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* create */
+         case 1:
+            /* NULL */
+            break;
+
+         /* join */
+         case 2:
+            /* NULL */
+            break;
+
+         /* invite */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* capability_negotiation */
+         case 4:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* callIndependentSupplementaryService */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q954Details                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Q954Details (OOCTXT* pctxt, H225Q954Details* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode conferenceCalling */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->conferenceCalling);
+   if (stat != ASN_OK) return stat;
+
+   /* encode threePartyService */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->threePartyService);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  QseriesOptions                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225QseriesOptions (OOCTXT* pctxt, H225QseriesOptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode q932Full */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q932Full);
+   if (stat != ASN_OK) return stat;
+
+   /* encode q951Full */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q951Full);
+   if (stat != ASN_OK) return stat;
+
+   /* encode q952Full */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q952Full);
+   if (stat != ASN_OK) return stat;
+
+   /* encode q953Full */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q953Full);
+   if (stat != ASN_OK) return stat;
+
+   /* encode q955Full */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q955Full);
+   if (stat != ASN_OK) return stat;
+
+   /* encode q956Full */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q956Full);
+   if (stat != ASN_OK) return stat;
+
+   /* encode q957Full */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q957Full);
+   if (stat != ASN_OK) return stat;
+
+   /* encode q954Info */
+
+   stat = asn1PE_H225Q954Details (pctxt, &pvalue->q954Info);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallType                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallType (OOCTXT* pctxt, H225CallType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* pointToPoint */
+         case 1:
+            /* NULL */
+            break;
+
+         /* oneToN */
+         case 2:
+            /* NULL */
+            break;
+
+         /* nToOne */
+         case 3:
+            /* NULL */
+            break;
+
+         /* nToN */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallIdentifier                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallIdentifier (OOCTXT* pctxt, H225CallIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode guid */
+
+   stat = asn1PE_H225GloballyUniqueID (pctxt, &pvalue->guid);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityServiceMode                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225SecurityServiceMode (OOCTXT* pctxt, H225SecurityServiceMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* none */
+         case 2:
+            /* NULL */
+            break;
+
+         /* default_ */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityCapabilities                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilities* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode encryption */
+
+   stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->encryption);
+   if (stat != ASN_OK) return stat;
+
+   /* encode authenticaton */
+
+   stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->authenticaton);
+   if (stat != ASN_OK) return stat;
+
+   /* encode integrity */
+
+   stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->integrity);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H245Security                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H245Security (OOCTXT* pctxt, H225H245Security* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* noSecurity */
+         case 2:
+            /* NULL */
+            break;
+
+         /* tls */
+         case 3:
+            stat = asn1PE_H225SecurityCapabilities (pctxt, pvalue->u.tls);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* ipsec */
+         case 4:
+            stat = asn1PE_H225SecurityCapabilities (pctxt, pvalue->u.ipsec);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225H245Security                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225H245Security (OOCTXT* pctxt, H225_SeqOfH225H245Security* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225H245Security (pctxt, ((H225H245Security*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ClearToken                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225ClearToken (OOCTXT* pctxt, H225_SeqOfH225ClearToken* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H235ClearToken (pctxt, ((H235ClearToken*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoEPPwdHash                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoEPPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPPwdHash* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode alias */
+
+   stat = asn1PE_H225AliasAddress (pctxt, &pvalue->alias);
+   if (stat != ASN_OK) return stat;
+
+   /* encode timeStamp */
+
+   stat = asn1PE_H235TimeStamp (pctxt, pvalue->timeStamp);
+   if (stat != ASN_OK) return stat;
+
+   /* encode token */
+
+   stat = asn1PE_H235HASHED (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoGKPwdHash                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoGKPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKPwdHash* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode gatekeeperId */
+
+   stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperId);
+   if (stat != ASN_OK) return stat;
+
+   /* encode timeStamp */
+
+   stat = asn1PE_H235TimeStamp (pctxt, pvalue->timeStamp);
+   if (stat != ASN_OK) return stat;
+
+   /* encode token */
+
+   stat = asn1PE_H235HASHED (pctxt, &pvalue->token);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoEPCert                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoEPCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPCert* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode toBeSigned */
+
+   stat = asn1PE_H235EncodedPwdCertToken (pctxt, pvalue->toBeSigned);
+   if (stat != ASN_OK) return stat;
+
+   /* encode algorithmOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode paramS */
+
+   stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   /* encode signature */
+
+   stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoGKCert                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoGKCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKCert* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode toBeSigned */
+
+   stat = asn1PE_H235EncodedPwdCertToken (pctxt, pvalue->toBeSigned);
+   if (stat != ASN_OK) return stat;
+
+   /* encode algorithmOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode paramS */
+
+   stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   /* encode signature */
+
+   stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token_cryptoFastStart                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CryptoH323Token_cryptoFastStart (OOCTXT* pctxt, H225CryptoH323Token_cryptoFastStart* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode toBeSigned */
+
+   stat = asn1PE_H225EncodedFastStartToken (pctxt, pvalue->toBeSigned);
+   if (stat != ASN_OK) return stat;
+
+   /* encode algorithmOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode paramS */
+
+   stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
+   if (stat != ASN_OK) return stat;
+
+   /* encode signature */
+
+   stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CryptoH323Token                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CryptoH323Token (OOCTXT* pctxt, H225CryptoH323Token* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 8);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* cryptoEPPwdHash */
+         case 1:
+            stat = asn1PE_H225CryptoH323Token_cryptoEPPwdHash (pctxt, pvalue->u.cryptoEPPwdHash);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoGKPwdHash */
+         case 2:
+            stat = asn1PE_H225CryptoH323Token_cryptoGKPwdHash (pctxt, pvalue->u.cryptoGKPwdHash);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoEPPwdEncr */
+         case 3:
+            stat = asn1PE_H235ENCRYPTED (pctxt, pvalue->u.cryptoEPPwdEncr);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoGKPwdEncr */
+         case 4:
+            stat = asn1PE_H235ENCRYPTED (pctxt, pvalue->u.cryptoGKPwdEncr);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoEPCert */
+         case 5:
+            stat = asn1PE_H225CryptoH323Token_cryptoEPCert (pctxt, pvalue->u.cryptoEPCert);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoGKCert */
+         case 6:
+            stat = asn1PE_H225CryptoH323Token_cryptoGKCert (pctxt, pvalue->u.cryptoGKCert);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cryptoFastStart */
+         case 7:
+            stat = asn1PE_H225CryptoH323Token_cryptoFastStart (pctxt, pvalue->u.cryptoFastStart);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nestedcryptoToken */
+         case 8:
+            stat = asn1PE_H235CryptoToken (pctxt, pvalue->u.nestedcryptoToken);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CryptoH323Token                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225CryptoH323Token (OOCTXT* pctxt, H225_SeqOfH225CryptoH323Token* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225CryptoH323Token (pctxt, ((H225CryptoH323Token*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_fastStart                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Setup_UUIE_fastStart (OOCTXT* pctxt, H225Setup_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ScnConnectionType                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ScnConnectionType (OOCTXT* pctxt, H225ScnConnectionType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 7);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unknown */
+         case 1:
+            /* NULL */
+            break;
+
+         /* bChannel */
+         case 2:
+            /* NULL */
+            break;
+
+         /* hybrid2x64 */
+         case 3:
+            /* NULL */
+            break;
+
+         /* hybrid384 */
+         case 4:
+            /* NULL */
+            break;
+
+         /* hybrid1536 */
+         case 5:
+            /* NULL */
+            break;
+
+         /* hybrid1920 */
+         case 6:
+            /* NULL */
+            break;
+
+         /* multirate */
+         case 7:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ScnConnectionAggregation                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ScnConnectionAggregation (OOCTXT* pctxt, H225ScnConnectionAggregation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* auto_ */
+         case 1:
+            /* NULL */
+            break;
+
+         /* none */
+         case 2:
+            /* NULL */
+            break;
+
+         /* h221 */
+         case 3:
+            /* NULL */
+            break;
+
+         /* bonded_mode1 */
+         case 4:
+            /* NULL */
+            break;
+
+         /* bonded_mode2 */
+         case 5:
+            /* NULL */
+            break;
+
+         /* bonded_mode3 */
+         case 6:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_connectionParameters                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Setup_UUIE_connectionParameters (OOCTXT* pctxt, H225Setup_UUIE_connectionParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode connectionType */
+
+   stat = asn1PE_H225ScnConnectionType (pctxt, &pvalue->connectionType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode numberOfScnConnections */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfScnConnections, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode connectionAggregation */
+
+   stat = asn1PE_H225ScnConnectionAggregation (pctxt, &pvalue->connectionAggregation);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_language                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Setup_UUIE_language (OOCTXT* pctxt, H225Setup_UUIE_language* pvalue)
+{
+   static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      addSizeConstraint (pctxt, &element_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->elem[xx1], 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PresentationIndicator                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225PresentationIndicator (OOCTXT* pctxt, H225PresentationIndicator* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* presentationAllowed */
+         case 1:
+            /* NULL */
+            break;
+
+         /* presentationRestricted */
+         case 2:
+            /* NULL */
+            break;
+
+         /* addressNotAvailable */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl_billingMode                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallCreditServiceControl_billingMode (OOCTXT* pctxt, H225CallCreditServiceControl_billingMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* credit */
+         case 1:
+            /* NULL */
+            break;
+
+         /* debit */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl_callStartingPoint                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallCreditServiceControl_callStartingPoint (OOCTXT* pctxt, H225CallCreditServiceControl_callStartingPoint* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* alerting */
+         case 1:
+            /* NULL */
+            break;
+
+         /* connect */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditServiceControl                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallCreditServiceControl (OOCTXT* pctxt, H225CallCreditServiceControl* pvalue)
+{
+   static Asn1SizeCnst amountString_lsize1 = { 0, 1, 512, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.amountStringPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.billingModePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callDurationLimitPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.enforceCallDurationLimitPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callStartingPointPresent);
+
+   /* encode amountString */
+
+   if (pvalue->m.amountStringPresent) {
+      addSizeConstraint (pctxt, &amountString_lsize1);
+
+      stat = encodeBMPString (pctxt, pvalue->amountString, 0);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode billingMode */
+
+   if (pvalue->m.billingModePresent) {
+      stat = asn1PE_H225CallCreditServiceControl_billingMode (pctxt, &pvalue->billingMode);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callDurationLimit */
+
+   if (pvalue->m.callDurationLimitPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->callDurationLimit, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode enforceCallDurationLimit */
+
+   if (pvalue->m.enforceCallDurationLimitPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->enforceCallDurationLimit);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callStartingPoint */
+
+   if (pvalue->m.callStartingPointPresent) {
+      stat = asn1PE_H225CallCreditServiceControl_callStartingPoint (pctxt, &pvalue->callStartingPoint);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlDescriptor                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ServiceControlDescriptor (OOCTXT* pctxt, H225ServiceControlDescriptor* pvalue)
+{
+   static Asn1SizeCnst url_lsize1 = { 0, 0, 512, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* url */
+         case 1:
+            addSizeConstraint (pctxt, &url_lsize1);
+
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.url, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* signal */
+         case 2:
+            stat = asn1PE_H225H248SignalsDescriptor (pctxt, *pvalue->u.signal);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nonStandard */
+         case 3:
+            stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* callCreditServiceControl */
+         case 4:
+            stat = asn1PE_H225CallCreditServiceControl (pctxt, pvalue->u.callCreditServiceControl);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlSession_reason                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ServiceControlSession_reason (OOCTXT* pctxt, H225ServiceControlSession_reason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* open */
+         case 1:
+            /* NULL */
+            break;
+
+         /* refresh */
+         case 2:
+            /* NULL */
+            break;
+
+         /* close */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlSession                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ServiceControlSession (OOCTXT* pctxt, H225ServiceControlSession* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.contentsPresent);
+
+   /* encode sessionId */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sessionId, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode contents */
+
+   if (pvalue->m.contentsPresent) {
+      stat = asn1PE_H225ServiceControlDescriptor (pctxt, &pvalue->contents);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode reason */
+
+   stat = asn1PE_H225ServiceControlSession_reason (pctxt, &pvalue->reason);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ServiceControlSession                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225ServiceControlSession (OOCTXT* pctxt, H225_SeqOfH225ServiceControlSession* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225ServiceControlSession (pctxt, ((H225ServiceControlSession*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CarrierInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CarrierInfo (OOCTXT* pctxt, H225CarrierInfo* pvalue)
+{
+   static Asn1SizeCnst carrierName_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.carrierIdentificationCodePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.carrierNamePresent);
+
+   /* encode carrierIdentificationCode */
+
+   if (pvalue->m.carrierIdentificationCodePresent) {
+      stat = asn1PE_H225CarrierInfo_carrierIdentificationCode (pctxt, &pvalue->carrierIdentificationCode);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode carrierName */
+
+   if (pvalue->m.carrierNamePresent) {
+      addSizeConstraint (pctxt, &carrierName_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->carrierName, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallsAvailable                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallsAvailable (OOCTXT* pctxt, H225CallsAvailable* pvalue)
+{
+   static Asn1SizeCnst group_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.carrierPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.groupPresent);
+
+   /* encode calls */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->calls, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   /* encode group */
+
+   if (pvalue->m.groupPresent) {
+      addSizeConstraint (pctxt, &group_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->group, 0, 8, 7, 7);
+      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.carrierPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.carrierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CarrierInfo (&lctxt, &pvalue->carrier);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CallsAvailable                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225CallsAvailable (OOCTXT* pctxt, H225_SeqOfH225CallsAvailable* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225CallsAvailable (pctxt, ((H225CallsAvailable*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCapacityInfo                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallCapacityInfo (OOCTXT* pctxt, H225CallCapacityInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.sipGwCallsAvailablePresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.voiceGwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h310GwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h320GwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h321GwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h322GwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h323GwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h324GwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.t120OnlyGwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxAnnexbOnlyGwCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalCallsAvailablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mcuCallsAvailablePresent);
+
+   /* encode voiceGwCallsAvailable */
+
+   if (pvalue->m.voiceGwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->voiceGwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode h310GwCallsAvailable */
+
+   if (pvalue->m.h310GwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h310GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode h320GwCallsAvailable */
+
+   if (pvalue->m.h320GwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h320GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode h321GwCallsAvailable */
+
+   if (pvalue->m.h321GwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h321GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode h322GwCallsAvailable */
+
+   if (pvalue->m.h322GwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h322GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode h323GwCallsAvailable */
+
+   if (pvalue->m.h323GwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h323GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode h324GwCallsAvailable */
+
+   if (pvalue->m.h324GwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h324GwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode t120OnlyGwCallsAvailable */
+
+   if (pvalue->m.t120OnlyGwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->t120OnlyGwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode t38FaxAnnexbOnlyGwCallsAvailable */
+
+   if (pvalue->m.t38FaxAnnexbOnlyGwCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->t38FaxAnnexbOnlyGwCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode terminalCallsAvailable */
+
+   if (pvalue->m.terminalCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->terminalCallsAvailable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mcuCallsAvailable */
+
+   if (pvalue->m.mcuCallsAvailablePresent) {
+      stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->mcuCallsAvailable);
+      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.sipGwCallsAvailablePresent);
+      /* encode extension elements */
+
+      if (pvalue->m.sipGwCallsAvailablePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CallsAvailable (&lctxt, &pvalue->sipGwCallsAvailable);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCapacity                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallCapacity (OOCTXT* pctxt, H225CallCapacity* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.maximumCallCapacityPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.currentCallCapacityPresent);
+
+   /* encode maximumCallCapacity */
+
+   if (pvalue->m.maximumCallCapacityPresent) {
+      stat = asn1PE_H225CallCapacityInfo (pctxt, &pvalue->maximumCallCapacity);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode currentCallCapacity */
+
+   if (pvalue->m.currentCallCapacityPresent) {
+      stat = asn1PE_H225CallCapacityInfo (pctxt, &pvalue->currentCallCapacity);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225CicInfo_cic_element                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225CicInfo_cic_element (OOCTXT* pctxt, H225_SeqOfH225CicInfo_cic_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H225CicInfo_cic_element (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CicInfo                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CicInfo (OOCTXT* pctxt, H225CicInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode cic */
+
+   stat = asn1PE_H225_SeqOfH225CicInfo_cic_element (pctxt, &pvalue->cic);
+   if (stat != ASN_OK) return stat;
+
+   /* encode pointCode */
+
+   stat = asn1PE_H225CicInfo_pointCode (pctxt, &pvalue->pointCode);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GroupID_member                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GroupID_member (OOCTXT* pctxt, H225GroupID_member* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 0U, 65535U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GroupID                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GroupID (OOCTXT* pctxt, H225GroupID* pvalue)
+{
+   static Asn1SizeCnst group_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.memberPresent);
+
+   /* encode member */
+
+   if (pvalue->m.memberPresent) {
+      stat = asn1PE_H225GroupID_member (pctxt, &pvalue->member);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode group */
+
+   addSizeConstraint (pctxt, &group_lsize1);
+
+   stat = encodeConstrainedStringEx (pctxt, pvalue->group, 0, 8, 7, 7);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CircuitIdentifier                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CircuitIdentifier (OOCTXT* pctxt, H225CircuitIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.carrierPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cicPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.groupPresent);
+
+   /* encode cic */
+
+   if (pvalue->m.cicPresent) {
+      stat = asn1PE_H225CicInfo (pctxt, &pvalue->cic);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode group */
+
+   if (pvalue->m.groupPresent) {
+      stat = asn1PE_H225GroupID (pctxt, &pvalue->group);
+      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.carrierPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.carrierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CarrierInfo (&lctxt, &pvalue->carrier);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225GenericData                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225GenericData (OOCTXT* pctxt, H225_SeqOfH225GenericData* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225GenericData (pctxt, ((H225GenericData*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CircuitInfo                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CircuitInfo (OOCTXT* pctxt, H225CircuitInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceCircuitIDPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationCircuitIDPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+
+   /* encode sourceCircuitID */
+
+   if (pvalue->m.sourceCircuitIDPresent) {
+      stat = asn1PE_H225CircuitIdentifier (pctxt, &pvalue->sourceCircuitID);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destinationCircuitID */
+
+   if (pvalue->m.destinationCircuitIDPresent) {
+      stat = asn1PE_H225CircuitIdentifier (pctxt, &pvalue->destinationCircuitID);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode genericData */
+
+   if (pvalue->m.genericDataPresent) {
+      stat = asn1PE_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225FeatureDescriptor                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225FeatureDescriptor (OOCTXT* pctxt, H225_SeqOfH225FeatureDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225FeatureDescriptor (pctxt, ((H225FeatureDescriptor*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE_parallelH245Control                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Setup_UUIE_parallelH245Control (OOCTXT* pctxt, H225Setup_UUIE_parallelH245Control* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ExtendedAliasAddress                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ExtendedAliasAddress (OOCTXT* pctxt, H225ExtendedAliasAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent);
+
+   /* encode address */
+
+   stat = asn1PE_H225AliasAddress (pctxt, &pvalue->address);
+   if (stat != ASN_OK) return stat;
+
+   /* encode presentationIndicator */
+
+   if (pvalue->m.presentationIndicatorPresent) {
+      stat = asn1PE_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode screeningIndicator */
+
+   if (pvalue->m.screeningIndicatorPresent) {
+      stat = asn1PE_H225ScreeningIndicator (pctxt, pvalue->screeningIndicator);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ExtendedAliasAddress                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225ExtendedAliasAddress (OOCTXT* pctxt, H225_SeqOfH225ExtendedAliasAddress* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225ExtendedAliasAddress (pctxt, ((H225ExtendedAliasAddress*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Setup_UUIE                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Setup_UUIE (OOCTXT* pctxt, H225Setup_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.sourceCallSignalAddressPresent ||
+   pvalue->m.remoteExtensionAddressPresent ||
+   pvalue->m.callIdentifierPresent ||
+   pvalue->m.h245SecurityCapabilityPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.fastStartPresent ||
+   pvalue->m.mediaWaitForConnectPresent ||
+   pvalue->m.canOverlapSendPresent ||
+   pvalue->m.endpointIdentifierPresent ||
+   pvalue->m.multipleCallsPresent ||
+   pvalue->m.maintainConnectionPresent ||
+   pvalue->m.connectionParametersPresent ||
+   pvalue->m.languagePresent ||
+   pvalue->m.presentationIndicatorPresent ||
+   pvalue->m.screeningIndicatorPresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.symmetricOperationRequiredPresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.desiredProtocolsPresent ||
+   pvalue->m.neededFeaturesPresent ||
+   pvalue->m.desiredFeaturesPresent ||
+   pvalue->m.supportedFeaturesPresent ||
+   pvalue->m.parallelH245ControlPresent ||
+   pvalue->m.additionalSourceAddressesPresent ||
+   pvalue->m.hopCountPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destCallSignalAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCRVPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callServicesPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode sourceAddress */
+
+   if (pvalue->m.sourceAddressPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->sourceAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode sourceInfo */
+
+   stat = asn1PE_H225EndpointType (pctxt, &pvalue->sourceInfo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode destinationAddress */
+
+   if (pvalue->m.destinationAddressPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destCallSignalAddress */
+
+   if (pvalue->m.destCallSignalAddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destExtraCallInfo */
+
+   if (pvalue->m.destExtraCallInfoPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destExtraCRV */
+
+   if (pvalue->m.destExtraCRVPresent) {
+      stat = asn1PE_H225_SeqOfH225CallReferenceValue (pctxt, &pvalue->destExtraCRV);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode activeMC */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->activeMC);
+   if (stat != ASN_OK) return stat;
+
+   /* encode conferenceID */
+
+   stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode conferenceGoal */
+
+   stat = asn1PE_H225Setup_UUIE_conferenceGoal (pctxt, &pvalue->conferenceGoal);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callServices */
+
+   if (pvalue->m.callServicesPresent) {
+      stat = asn1PE_H225QseriesOptions (pctxt, &pvalue->callServices);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callType */
+
+   stat = asn1PE_H225CallType (pctxt, &pvalue->callType);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 26);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceCallSignalAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaWaitForConnectPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.canOverlapSendPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.connectionParametersPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.languagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.symmetricOperationRequiredPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredProtocolsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.neededFeaturesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredFeaturesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedFeaturesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.parallelH245ControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.additionalSourceAddressesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.hopCountPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.sourceCallSignalAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225TransportAddress (&lctxt, &pvalue->sourceCallSignalAddress);
+         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.remoteExtensionAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AliasAddress (&lctxt, &pvalue->remoteExtensionAddress);
+         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.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.h245SecurityCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225H245Security (&lctxt, &pvalue->h245SecurityCapability);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.fastStartPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Setup_UUIE_fastStart (&lctxt, &pvalue->fastStart);
+         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.mediaWaitForConnectPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->mediaWaitForConnect);
+         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.canOverlapSendPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canOverlapSend);
+         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.endpointIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225EndpointIdentifier (&lctxt, pvalue->endpointIdentifier);
+         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.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.maintainConnectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection);
+         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.connectionParametersPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Setup_UUIE_connectionParameters (&lctxt, &pvalue->connectionParameters);
+         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.languagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Setup_UUIE_language (&lctxt, &pvalue->language);
+         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.presentationIndicatorPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225PresentationIndicator (&lctxt, &pvalue->presentationIndicator);
+         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.screeningIndicatorPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ScreeningIndicator (&lctxt, pvalue->screeningIndicator);
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.symmetricOperationRequiredPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.desiredProtocolsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->desiredProtocols);
+         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.neededFeaturesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225FeatureDescriptor (&lctxt, &pvalue->neededFeatures);
+         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.desiredFeaturesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225FeatureDescriptor (&lctxt, &pvalue->desiredFeatures);
+         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.supportedFeaturesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225FeatureDescriptor (&lctxt, &pvalue->supportedFeatures);
+         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.parallelH245ControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Setup_UUIE_parallelH245Control (&lctxt, &pvalue->parallelH245Control);
+         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.additionalSourceAddressesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ExtendedAliasAddress (&lctxt, &pvalue->additionalSourceAddresses);
+         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.hopCountPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->hopCount, 1U, 31U);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallProceeding_UUIE_fastStart                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallProceeding_UUIE_fastStart (OOCTXT* pctxt, H225CallProceeding_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FeatureSet                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225FeatureSet (OOCTXT* pctxt, H225FeatureSet* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.neededFeaturesPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredFeaturesPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedFeaturesPresent);
+
+   /* encode replacementFeatureSet */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->replacementFeatureSet);
+   if (stat != ASN_OK) return stat;
+
+   /* encode neededFeatures */
+
+   if (pvalue->m.neededFeaturesPresent) {
+      stat = asn1PE_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->neededFeatures);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode desiredFeatures */
+
+   if (pvalue->m.desiredFeaturesPresent) {
+      stat = asn1PE_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->desiredFeatures);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode supportedFeatures */
+
+   if (pvalue->m.supportedFeaturesPresent) {
+      stat = asn1PE_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->supportedFeatures);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallProceeding_UUIE                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallProceeding_UUIE (OOCTXT* pctxt, H225CallProceeding_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.h245SecurityModePresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.fastStartPresent ||
+   pvalue->m.multipleCallsPresent ||
+   pvalue->m.maintainConnectionPresent ||
+   pvalue->m.fastConnectRefusedPresent ||
+   pvalue->m.featureSetPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode destinationInfo */
+
+   stat = asn1PE_H225EndpointType (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 8);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.h245SecurityModePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225H245Security (&lctxt, &pvalue->h245SecurityMode);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.fastStartPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallProceeding_UUIE_fastStart (&lctxt, &pvalue->fastStart);
+         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.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.maintainConnectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection);
+         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.fastConnectRefusedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE_fastStart                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Connect_UUIE_fastStart (OOCTXT* pctxt, H225Connect_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE_language                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Connect_UUIE_language (OOCTXT* pctxt, H225Connect_UUIE_language* pvalue)
+{
+   static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      addSizeConstraint (pctxt, &element_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->elem[xx1], 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Connect_UUIE                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Connect_UUIE (OOCTXT* pctxt, H225Connect_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.h245SecurityModePresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.fastStartPresent ||
+   pvalue->m.multipleCallsPresent ||
+   pvalue->m.maintainConnectionPresent ||
+   pvalue->m.languagePresent ||
+   pvalue->m.connectedAddressPresent ||
+   pvalue->m.presentationIndicatorPresent ||
+   pvalue->m.screeningIndicatorPresent ||
+   pvalue->m.fastConnectRefusedPresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.featureSetPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destinationInfo */
+
+   stat = asn1PE_H225EndpointType (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode conferenceID */
+
+   stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 14);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.languagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.connectedAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.h245SecurityModePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225H245Security (&lctxt, &pvalue->h245SecurityMode);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.fastStartPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Connect_UUIE_fastStart (&lctxt, &pvalue->fastStart);
+         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.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.maintainConnectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection);
+         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.languagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Connect_UUIE_language (&lctxt, &pvalue->language);
+         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.connectedAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->connectedAddress);
+         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.presentationIndicatorPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225PresentationIndicator (&lctxt, &pvalue->presentationIndicator);
+         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.screeningIndicatorPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ScreeningIndicator (&lctxt, pvalue->screeningIndicator);
+         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.fastConnectRefusedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Alerting_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Alerting_UUIE_fastStart (OOCTXT* pctxt, H225Alerting_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Alerting_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Alerting_UUIE (OOCTXT* pctxt, H225Alerting_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.h245SecurityModePresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.fastStartPresent ||
+   pvalue->m.multipleCallsPresent ||
+   pvalue->m.maintainConnectionPresent ||
+   pvalue->m.alertingAddressPresent ||
+   pvalue->m.presentationIndicatorPresent ||
+   pvalue->m.screeningIndicatorPresent ||
+   pvalue->m.fastConnectRefusedPresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.featureSetPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode destinationInfo */
+
+   stat = asn1PE_H225EndpointType (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 13);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alertingAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.h245SecurityModePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225H245Security (&lctxt, &pvalue->h245SecurityMode);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.fastStartPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Alerting_UUIE_fastStart (&lctxt, &pvalue->fastStart);
+         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.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.maintainConnectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection);
+         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.alertingAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->alertingAddress);
+         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.presentationIndicatorPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225PresentationIndicator (&lctxt, &pvalue->presentationIndicator);
+         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.screeningIndicatorPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ScreeningIndicator (&lctxt, pvalue->screeningIndicator);
+         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.fastConnectRefusedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Information_UUIE_fastStart                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Information_UUIE_fastStart (OOCTXT* pctxt, H225Information_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Information_UUIE                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Information_UUIE (OOCTXT* pctxt, H225Information_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.fastStartPresent ||
+   pvalue->m.fastConnectRefusedPresent ||
+   pvalue->m.circuitInfoPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   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.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.fastStartPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Information_UUIE_fastStart (&lctxt, &pvalue->fastStart);
+         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.fastConnectRefusedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityErrors                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225SecurityErrors (OOCTXT* pctxt, H225SecurityErrors* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 16);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 15);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* securityWrongSyncTime */
+         case 1:
+            /* NULL */
+            break;
+
+         /* securityReplay */
+         case 2:
+            /* NULL */
+            break;
+
+         /* securityWrongGeneralID */
+         case 3:
+            /* NULL */
+            break;
+
+         /* securityWrongSendersID */
+         case 4:
+            /* NULL */
+            break;
+
+         /* securityIntegrityFailed */
+         case 5:
+            /* NULL */
+            break;
+
+         /* securityWrongOID */
+         case 6:
+            /* NULL */
+            break;
+
+         /* securityDHmismatch */
+         case 7:
+            /* NULL */
+            break;
+
+         /* securityCertificateExpired */
+         case 8:
+            /* NULL */
+            break;
+
+         /* securityCertificateDateInvalid */
+         case 9:
+            /* NULL */
+            break;
+
+         /* securityCertificateRevoked */
+         case 10:
+            /* NULL */
+            break;
+
+         /* securityCertificateNotReadable */
+         case 11:
+            /* NULL */
+            break;
+
+         /* securityCertificateSignatureInvalid */
+         case 12:
+            /* NULL */
+            break;
+
+         /* securityCertificateMissing */
+         case 13:
+            /* NULL */
+            break;
+
+         /* securityCertificateIncomplete */
+         case 14:
+            /* NULL */
+            break;
+
+         /* securityUnsupportedCertificateAlgOID */
+         case 15:
+            /* NULL */
+            break;
+
+         /* securityUnknownCA */
+         case 16:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 17);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ReleaseCompleteReason                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ReleaseCompleteReason (OOCTXT* pctxt, H225ReleaseCompleteReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 12);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 11);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* noBandwidth */
+         case 1:
+            /* NULL */
+            break;
+
+         /* gatekeeperResources */
+         case 2:
+            /* NULL */
+            break;
+
+         /* unreachableDestination */
+         case 3:
+            /* NULL */
+            break;
+
+         /* destinationRejection */
+         case 4:
+            /* NULL */
+            break;
+
+         /* invalidRevision */
+         case 5:
+            /* NULL */
+            break;
+
+         /* noPermission */
+         case 6:
+            /* NULL */
+            break;
+
+         /* unreachableGatekeeper */
+         case 7:
+            /* NULL */
+            break;
+
+         /* gatewayResources */
+         case 8:
+            /* NULL */
+            break;
+
+         /* badFormatAddress */
+         case 9:
+            /* NULL */
+            break;
+
+         /* adaptiveBusy */
+         case 10:
+            /* NULL */
+            break;
+
+         /* inConf */
+         case 11:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 12:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 13);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* facilityCallDeflection */
+         case 13:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityDenied */
+         case 14:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* calledPartyNotRegistered */
+         case 15:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* callerNotRegistered */
+         case 16:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* newConnectionNeeded */
+         case 17:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* nonStandardReason */
+         case 18:
+            stat = asn1PE_H225NonStandardParameter (&lctxt, pvalue->u.nonStandardReason);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* replaceWithConferenceInvite */
+         case 19:
+            stat = asn1PE_H225ConferenceIdentifier (&lctxt, pvalue->u.replaceWithConferenceInvite);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericDataReason */
+         case 20:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* neededFeatureNotSupported */
+         case 21:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* tunnelledSignallingRejected */
+         case 22:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* invalidCID */
+         case 23:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityError */
+         case 24:
+            stat = asn1PE_H225SecurityErrors (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* hopCountExceeded */
+         case 25:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ReleaseComplete_UUIE                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ReleaseComplete_UUIE (OOCTXT* pctxt, H225ReleaseComplete_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.busyAddressPresent ||
+   pvalue->m.presentationIndicatorPresent ||
+   pvalue->m.screeningIndicatorPresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.featureSetPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.reasonPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode reason */
+
+   if (pvalue->m.reasonPresent) {
+      stat = asn1PE_H225ReleaseCompleteReason (pctxt, &pvalue->reason);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 8);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.busyAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.busyAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->busyAddress);
+         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.presentationIndicatorPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225PresentationIndicator (&lctxt, &pvalue->presentationIndicator);
+         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.screeningIndicatorPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ScreeningIndicator (&lctxt, pvalue->screeningIndicator);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FacilityReason                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225FacilityReason (OOCTXT* pctxt, H225FacilityReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* routeCallToGatekeeper */
+         case 1:
+            /* NULL */
+            break;
+
+         /* callForwarded */
+         case 2:
+            /* NULL */
+            break;
+
+         /* routeCallToMC */
+         case 3:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* conferenceListChoice */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* startH245 */
+         case 6:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* noH245 */
+         case 7:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* newTokens */
+         case 8:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* featureSetUpdate */
+         case 9:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* forwardedElements */
+         case 10:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* transportedInformation */
+         case 11:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceList                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ConferenceList (OOCTXT* pctxt, H225ConferenceList* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.conferenceIDPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.conferenceAliasPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode conferenceID */
+
+   if (pvalue->m.conferenceIDPresent) {
+      stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode conferenceAlias */
+
+   if (pvalue->m.conferenceAliasPresent) {
+      stat = asn1PE_H225AliasAddress (pctxt, &pvalue->conferenceAlias);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ConferenceList                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225ConferenceList (OOCTXT* pctxt, H225_SeqOfH225ConferenceList* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225ConferenceList (pctxt, ((H225ConferenceList*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Facility_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Facility_UUIE_fastStart (OOCTXT* pctxt, H225Facility_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Facility_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Facility_UUIE (OOCTXT* pctxt, H225Facility_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.destExtraCallInfoPresent ||
+   pvalue->m.remoteExtensionAddressPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.conferencesPresent ||
+   pvalue->m.h245AddressPresent ||
+   pvalue->m.fastStartPresent ||
+   pvalue->m.multipleCallsPresent ||
+   pvalue->m.maintainConnectionPresent ||
+   pvalue->m.fastConnectRefusedPresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.destinationInfoPresent ||
+   pvalue->m.h245SecurityModePresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternativeAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternativeAliasAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.conferenceIDPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alternativeAddress */
+
+   if (pvalue->m.alternativeAddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->alternativeAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode alternativeAliasAddress */
+
+   if (pvalue->m.alternativeAliasAddressPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->alternativeAliasAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode conferenceID */
+
+   if (pvalue->m.conferenceIDPresent) {
+      stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode reason */
+
+   stat = asn1PE_H225FacilityReason (pctxt, &pvalue->reason);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 15);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.conferencesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.destExtraCallInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destExtraCallInfo);
+         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.remoteExtensionAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AliasAddress (&lctxt, &pvalue->remoteExtensionAddress);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.conferencesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ConferenceList (&lctxt, &pvalue->conferences);
+         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.h245AddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225TransportAddress (&lctxt, &pvalue->h245Address);
+         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.fastStartPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225Facility_UUIE_fastStart (&lctxt, &pvalue->fastStart);
+         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.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.maintainConnectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection);
+         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.fastConnectRefusedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.destinationInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225EndpointType (&lctxt, &pvalue->destinationInfo);
+         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.h245SecurityModePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225H245Security (&lctxt, &pvalue->h245SecurityMode);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Progress_UUIE_fastStart                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Progress_UUIE_fastStart (OOCTXT* pctxt, H225Progress_UUIE_fastStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Progress_UUIE                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Progress_UUIE (OOCTXT* pctxt, H225Progress_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.multipleCallsPresent ||
+   pvalue->m.maintainConnectionPresent ||
+   pvalue->m.fastConnectRefusedPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode destinationInfo */
+
+   stat = asn1PE_H225EndpointType (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h245Address */
+
+   if (pvalue->m.h245AddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callIdentifier */
+
+   stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h245SecurityMode */
+
+   if (pvalue->m.h245SecurityModePresent) {
+      stat = asn1PE_H225H245Security (pctxt, &pvalue->h245SecurityMode);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode fastStart */
+
+   if (pvalue->m.fastStartPresent) {
+      stat = asn1PE_H225Progress_UUIE_fastStart (pctxt, &pvalue->fastStart);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.maintainConnectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection);
+         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.fastConnectRefusedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Status_UUIE                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Status_UUIE (OOCTXT* pctxt, H225Status_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callIdentifier */
+
+   stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  StatusInquiry_UUIE                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225StatusInquiry_UUIE (OOCTXT* pctxt, H225StatusInquiry_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callIdentifier */
+
+   stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SetupAcknowledge_UUIE                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225SetupAcknowledge_UUIE (OOCTXT* pctxt, H225SetupAcknowledge_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callIdentifier */
+
+   stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Notify_UUIE                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Notify_UUIE (OOCTXT* pctxt, H225Notify_UUIE* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callIdentifier */
+
+   stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h323_message_body                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UU_PDU_h323_message_body (OOCTXT* pctxt, H225H323_UU_PDU_h323_message_body* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 7);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* setup */
+         case 1:
+            stat = asn1PE_H225Setup_UUIE (pctxt, pvalue->u.setup);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* callProceeding */
+         case 2:
+            stat = asn1PE_H225CallProceeding_UUIE (pctxt, pvalue->u.callProceeding);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* connect */
+         case 3:
+            stat = asn1PE_H225Connect_UUIE (pctxt, pvalue->u.connect);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* alerting */
+         case 4:
+            stat = asn1PE_H225Alerting_UUIE (pctxt, pvalue->u.alerting);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* information */
+         case 5:
+            stat = asn1PE_H225Information_UUIE (pctxt, pvalue->u.information);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* releaseComplete */
+         case 6:
+            stat = asn1PE_H225ReleaseComplete_UUIE (pctxt, pvalue->u.releaseComplete);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* facility */
+         case 7:
+            stat = asn1PE_H225Facility_UUIE (pctxt, pvalue->u.facility);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* progress */
+         case 8:
+            stat = asn1PE_H225Progress_UUIE (&lctxt, pvalue->u.progress);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* empty */
+         case 9:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* status */
+         case 10:
+            stat = asn1PE_H225Status_UUIE (&lctxt, pvalue->u.status);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* statusInquiry */
+         case 11:
+            stat = asn1PE_H225StatusInquiry_UUIE (&lctxt, pvalue->u.statusInquiry);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* setupAcknowledge */
+         case 12:
+            stat = asn1PE_H225SetupAcknowledge_UUIE (&lctxt, pvalue->u.setupAcknowledge);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* notify */
+         case 13:
+            stat = asn1PE_H225Notify_UUIE (&lctxt, pvalue->u.notify);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h4501SupplementaryService                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UU_PDU_h4501SupplementaryService (OOCTXT* pctxt, H225H323_UU_PDU_h4501SupplementaryService* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_h245Control                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UU_PDU_h245Control (OOCTXT* pctxt, H225H323_UU_PDU_h245Control* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225NonStandardParameter                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225NonStandardParameter (OOCTXT* pctxt, H225_SeqOfH225NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225NonStandardParameter (pctxt, ((H225NonStandardParameter*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallLinkage                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallLinkage (OOCTXT* pctxt, H225CallLinkage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.globalCallIdPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.threadIdPresent);
+
+   /* encode globalCallId */
+
+   if (pvalue->m.globalCallIdPresent) {
+      stat = asn1PE_H225GloballyUniqueID (pctxt, &pvalue->globalCallId);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode threadId */
+
+   if (pvalue->m.threadIdPresent) {
+      stat = asn1PE_H225GloballyUniqueID (pctxt, &pvalue->threadId);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_tunnelledSignallingMessage_messageContent     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage_messageContent* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU_tunnelledSignallingMessage                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tunnellingRequiredPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode tunnelledProtocolID */
+
+   stat = asn1PE_H225TunnelledProtocol (pctxt, &pvalue->tunnelledProtocolID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode messageContent */
+
+   stat = asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (pctxt, &pvalue->messageContent);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tunnellingRequired */
+
+   if (pvalue->m.tunnellingRequiredPresent) {
+      /* NULL */
+   }
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  StimulusControl                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225StimulusControl (OOCTXT* pctxt, H225StimulusControl* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.isTextPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h248MessagePresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode isText */
+
+   if (pvalue->m.isTextPresent) {
+      /* NULL */
+   }
+
+   /* encode h248Message */
+
+   if (pvalue->m.h248MessagePresent) {
+      stat = encodeOctetString (pctxt, pvalue->h248Message.numocts, pvalue->h248Message.data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UU_PDU                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UU_PDU (OOCTXT* pctxt, H225H323_UU_PDU* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.h4501SupplementaryServicePresent ||
+   pvalue->m.h245TunnelingPresent ||
+   pvalue->m.h245ControlPresent ||
+   pvalue->m.nonStandardControlPresent ||
+   pvalue->m.callLinkagePresent ||
+   pvalue->m.tunnelledSignallingMessagePresent ||
+   pvalue->m.provisionalRespToH245TunnelingPresent ||
+   pvalue->m.stimulusControlPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode h323_message_body */
+
+   stat = asn1PE_H225H323_UU_PDU_h323_message_body (pctxt, &pvalue->h323_message_body);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 8);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h4501SupplementaryServicePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245TunnelingPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245ControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tunnelledSignallingMessagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.provisionalRespToH245TunnelingPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.stimulusControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.h4501SupplementaryServicePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225H323_UU_PDU_h4501SupplementaryService (&lctxt, &pvalue->h4501SupplementaryService);
+         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.h245TunnelingPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->h245Tunneling);
+         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.h245ControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225H323_UU_PDU_h245Control (&lctxt, &pvalue->h245Control);
+         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.nonStandardControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225NonStandardParameter (&lctxt, &pvalue->nonStandardControl);
+         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.callLinkagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage);
+         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.tunnelledSignallingMessagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage (&lctxt, &pvalue->tunnelledSignallingMessage);
+         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.provisionalRespToH245TunnelingPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.stimulusControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225StimulusControl (&lctxt, &pvalue->stimulusControl);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation_user_data                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UserInformation_user_data (OOCTXT* pctxt, H225H323_UserInformation_user_data* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode protocol_discriminator */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->protocol_discriminator, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode user_information */
+
+   stat = asn1PE_H225H323_UserInformation_user_data_user_information (pctxt, &pvalue->user_information);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H323_UserInformation                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225H323_UserInformation (OOCTXT* pctxt, H225H323_UserInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.user_dataPresent);
+
+   /* encode h323_uu_pdu */
+
+   stat = asn1PE_H225H323_UU_PDU (pctxt, &pvalue->h323_uu_pdu);
+   if (stat != ASN_OK) return stat;
+
+   /* encode user_data */
+
+   if (pvalue->m.user_dataPresent) {
+      stat = asn1PE_H225H323_UserInformation_user_data (pctxt, &pvalue->user_data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AddressPattern_range                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AddressPattern_range (OOCTXT* pctxt, H225AddressPattern_range* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode startOfRange */
+
+   stat = asn1PE_H225PartyNumber (pctxt, &pvalue->startOfRange);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endOfRange */
+
+   stat = asn1PE_H225PartyNumber (pctxt, &pvalue->endOfRange);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AddressPattern                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AddressPattern (OOCTXT* pctxt, H225AddressPattern* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* wildcard */
+         case 1:
+            stat = asn1PE_H225AliasAddress (pctxt, pvalue->u.wildcard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* range */
+         case 2:
+            stat = asn1PE_H225AddressPattern_range (pctxt, pvalue->u.range);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportAddress                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225TransportAddress (OOCTXT* pctxt, H225_SeqOfH225TransportAddress* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225TransportAddress (pctxt, ((H225TransportAddress*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AlternateTransportAddresses                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AlternateTransportAddresses (OOCTXT* pctxt, H225AlternateTransportAddresses* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.sctpPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.annexEPresent);
+
+   /* encode annexE */
+
+   if (pvalue->m.annexEPresent) {
+      stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->annexE);
+      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.sctpPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.sctpPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225TransportAddress (&lctxt, &pvalue->sctp);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Endpoint                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225Endpoint (OOCTXT* pctxt, H225Endpoint* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.alternateTransportAddressesPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.featureSetPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.aliasAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callSignalAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.rasAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointTypePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.priorityPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode aliasAddress */
+
+   if (pvalue->m.aliasAddressPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->aliasAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callSignalAddress */
+
+   if (pvalue->m.callSignalAddressPresent) {
+      stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode rasAddress */
+
+   if (pvalue->m.rasAddressPresent) {
+      stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->rasAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode endpointType */
+
+   if (pvalue->m.endpointTypePresent) {
+      stat = asn1PE_H225EndpointType (pctxt, &pvalue->endpointType);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode priority */
+
+   if (pvalue->m.priorityPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->priority, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode remoteExtensionAddress */
+
+   if (pvalue->m.remoteExtensionAddressPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destExtraCallInfo */
+
+   if (pvalue->m.destExtraCallInfoPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.alternateTransportAddressesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UseSpecifiedTransport                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225UseSpecifiedTransport (OOCTXT* pctxt, H225UseSpecifiedTransport* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* tcp */
+         case 1:
+            /* NULL */
+            break;
+
+         /* annexE */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* sctp */
+         case 3:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AlternateGK                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AlternateGK (OOCTXT* pctxt, H225AlternateGK* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+
+   /* encode rasAddress */
+
+   stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode needToRegister */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->needToRegister);
+   if (stat != ASN_OK) return stat;
+
+   /* encode priority */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->priority, 0U, 127U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AlternateGK                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225AlternateGK (OOCTXT* pctxt, H225_SeqOfH225AlternateGK* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225AlternateGK (pctxt, ((H225AlternateGK*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AltGKInfo                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AltGKInfo (OOCTXT* pctxt, H225AltGKInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode alternateGatekeeper */
+
+   stat = asn1PE_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
+   if (stat != ASN_OK) return stat;
+
+   /* encode altGKisPermanent */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->altGKisPermanent);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SecurityErrors2                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225SecurityErrors2 (OOCTXT* pctxt, H225SecurityErrors2* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* securityWrongSyncTime */
+         case 1:
+            /* NULL */
+            break;
+
+         /* securityReplay */
+         case 2:
+            /* NULL */
+            break;
+
+         /* securityWrongGeneralID */
+         case 3:
+            /* NULL */
+            break;
+
+         /* securityWrongSendersID */
+         case 4:
+            /* NULL */
+            break;
+
+         /* securityIntegrityFailed */
+         case 5:
+            /* NULL */
+            break;
+
+         /* securityWrongOID */
+         case 6:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptIntAlg                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225EncryptIntAlg (OOCTXT* pctxt, H225EncryptIntAlg* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* isoAlgorithm */
+         case 2:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.isoAlgorithm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonIsoIntegrityMechanism                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225NonIsoIntegrityMechanism (OOCTXT* pctxt, H225NonIsoIntegrityMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* hMAC_MD5 */
+         case 1:
+            /* NULL */
+            break;
+
+         /* hMAC_iso10118_2_s */
+         case 2:
+            stat = asn1PE_H225EncryptIntAlg (pctxt, pvalue->u.hMAC_iso10118_2_s);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* hMAC_iso10118_2_l */
+         case 3:
+            stat = asn1PE_H225EncryptIntAlg (pctxt, pvalue->u.hMAC_iso10118_2_l);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* hMAC_iso10118_3 */
+         case 4:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.hMAC_iso10118_3);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IntegrityMechanism                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225IntegrityMechanism (OOCTXT* pctxt, H225IntegrityMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* digSig */
+         case 2:
+            /* NULL */
+            break;
+
+         /* iso9797 */
+         case 3:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.iso9797);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nonIsoIM */
+         case 4:
+            stat = asn1PE_H225NonIsoIntegrityMechanism (pctxt, pvalue->u.nonIsoIM);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ICV                                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ICV (OOCTXT* pctxt, H225ICV* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode algorithmOID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode icv */
+
+   stat = encodeBitString (pctxt, pvalue->icv.numbits, pvalue->icv.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingCapability                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CapacityReportingCapability (OOCTXT* pctxt, H225CapacityReportingCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode canReportCallCapacity */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->canReportCallCapacity);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingSpecification_when                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CapacityReportingSpecification_when (OOCTXT* pctxt, H225CapacityReportingSpecification_when* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callStartPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callEndPresent);
+
+   /* encode callStart */
+
+   if (pvalue->m.callStartPresent) {
+      /* NULL */
+   }
+
+   /* encode callEnd */
+
+   if (pvalue->m.callEndPresent) {
+      /* NULL */
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapacityReportingSpecification                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CapacityReportingSpecification (OOCTXT* pctxt, H225CapacityReportingSpecification* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode when */
+
+   stat = asn1PE_H225CapacityReportingSpecification_when (pctxt, &pvalue->when);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageInfoTypes                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RasUsageInfoTypes (OOCTXT* pctxt, H225RasUsageInfoTypes* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.startTimePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endTimePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminationCausePresent);
+
+   /* encode nonStandardUsageTypes */
+
+   stat = asn1PE_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardUsageTypes);
+   if (stat != ASN_OK) return stat;
+
+   /* encode startTime */
+
+   if (pvalue->m.startTimePresent) {
+      /* NULL */
+   }
+
+   /* encode endTime */
+
+   if (pvalue->m.endTimePresent) {
+      /* NULL */
+   }
+
+   /* encode terminationCause */
+
+   if (pvalue->m.terminationCausePresent) {
+      /* NULL */
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification_when                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RasUsageSpecification_when (OOCTXT* pctxt, H225RasUsageSpecification_when* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.startPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.inIrrPresent);
+
+   /* encode start */
+
+   if (pvalue->m.startPresent) {
+      /* NULL */
+   }
+
+   /* encode end */
+
+   if (pvalue->m.endPresent) {
+      /* NULL */
+   }
+
+   /* encode inIrr */
+
+   if (pvalue->m.inIrrPresent) {
+      /* NULL */
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification_callStartingPoint                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RasUsageSpecification_callStartingPoint (OOCTXT* pctxt, H225RasUsageSpecification_callStartingPoint* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.alertingPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.connectPresent);
+
+   /* encode alerting */
+
+   if (pvalue->m.alertingPresent) {
+      /* NULL */
+   }
+
+   /* encode connect */
+
+   if (pvalue->m.connectPresent) {
+      /* NULL */
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageSpecification                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RasUsageSpecification (OOCTXT* pctxt, H225RasUsageSpecification* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callStartingPointPresent);
+
+   /* encode when */
+
+   stat = asn1PE_H225RasUsageSpecification_when (pctxt, &pvalue->when);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callStartingPoint */
+
+   if (pvalue->m.callStartingPointPresent) {
+      stat = asn1PE_H225RasUsageSpecification_callStartingPoint (pctxt, &pvalue->callStartingPoint);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode required */
+
+   stat = asn1PE_H225RasUsageInfoTypes (pctxt, &pvalue->required);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasUsageInformation                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RasUsageInformation (OOCTXT* pctxt, H225RasUsageInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.alertingTimePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.connectTimePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endTimePresent);
+
+   /* encode nonStandardUsageFields */
+
+   stat = asn1PE_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardUsageFields);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alertingTime */
+
+   if (pvalue->m.alertingTimePresent) {
+      stat = asn1PE_H235TimeStamp (pctxt, pvalue->alertingTime);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode connectTime */
+
+   if (pvalue->m.connectTimePresent) {
+      stat = asn1PE_H235TimeStamp (pctxt, pvalue->connectTime);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode endTime */
+
+   if (pvalue->m.endTimePresent) {
+      stat = asn1PE_H235TimeStamp (pctxt, pvalue->endTime);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallTerminationCause                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallTerminationCause (OOCTXT* pctxt, H225CallTerminationCause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* releaseCompleteReason */
+         case 1:
+            stat = asn1PE_H225ReleaseCompleteReason (pctxt, pvalue->u.releaseCompleteReason);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* releaseCompleteCauseIE */
+         case 2:
+            stat = asn1PE_H225CallTerminationCause_releaseCompleteCauseIE (pctxt, pvalue->u.releaseCompleteCauseIE);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportChannelInfo                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportChannelInfo (OOCTXT* pctxt, H225TransportChannelInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sendAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.recvAddressPresent);
+
+   /* encode sendAddress */
+
+   if (pvalue->m.sendAddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->sendAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode recvAddress */
+
+   if (pvalue->m.recvAddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->recvAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthDetails                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225BandwidthDetails (OOCTXT* pctxt, H225BandwidthDetails* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sender */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->sender);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multicast */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multicast);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bandwidth */
+
+   stat = asn1PE_H225BandWidth (pctxt, pvalue->bandwidth);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rtcpAddresses */
+
+   stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->rtcpAddresses);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallCreditCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallCreditCapability (OOCTXT* pctxt, H225CallCreditCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.canDisplayAmountStringPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.canEnforceDurationLimitPresent);
+
+   /* encode canDisplayAmountString */
+
+   if (pvalue->m.canDisplayAmountStringPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->canDisplayAmountString);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode canEnforceDurationLimit */
+
+   if (pvalue->m.canEnforceDurationLimitPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->canEnforceDurationLimit);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPSession_associatedSessionIds                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RTPSession_associatedSessionIds (OOCTXT* pctxt, H225RTPSession_associatedSessionIds* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 1U, 255U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPSession                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RTPSession (OOCTXT* pctxt, H225RTPSession* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.multicastPresent ||
+   pvalue->m.bandwidthPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode rtpAddress */
+
+   stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->rtpAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rtcpAddress */
+
+   stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->rtcpAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cname */
+
+   stat = encodeConstrainedStringEx (pctxt, pvalue->cname, 0, 8, 7, 7);
+   if (stat != ASN_OK) return stat;
+
+   /* encode ssrc */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->ssrc, 1U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sessionId */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sessionId, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode associatedSessionIds */
+
+   stat = asn1PE_H225RTPSession_associatedSessionIds (pctxt, &pvalue->associatedSessionIds);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multicastPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.bandwidthPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.multicastPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.bandwidthPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225BandWidth (&lctxt, pvalue->bandwidth);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225Endpoint                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225Endpoint (OOCTXT* pctxt, H225_SeqOfH225Endpoint* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225Endpoint (pctxt, ((H225Endpoint*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AuthenticationMechanism                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225AuthenticationMechanism (OOCTXT* pctxt, H225_SeqOfH225AuthenticationMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H235AuthenticationMechanism (pctxt, ((H235AuthenticationMechanism*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRequest_algorithmOIDs                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GatekeeperRequest_algorithmOIDs (OOCTXT* pctxt, H225GatekeeperRequest_algorithmOIDs* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeObjectIdentifier (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225IntegrityMechanism                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225IntegrityMechanism (OOCTXT* pctxt, H225_SeqOfH225IntegrityMechanism* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225IntegrityMechanism (pctxt, ((H225IntegrityMechanism*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRequest                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GatekeeperRequest (OOCTXT* pctxt, H225GatekeeperRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.alternateEndpointsPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.authenticationCapabilityPresent ||
+   pvalue->m.algorithmOIDsPresent ||
+   pvalue->m.integrityPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.supportsAltGKPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callServicesPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointAliasPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode rasAddress */
+
+   stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointType */
+
+   stat = asn1PE_H225EndpointType (pctxt, &pvalue->endpointType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callServices */
+
+   if (pvalue->m.callServicesPresent) {
+      stat = asn1PE_H225QseriesOptions (pctxt, &pvalue->callServices);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode endpointAlias */
+
+   if (pvalue->m.endpointAliasPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 9);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.authenticationCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.algorithmOIDsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportsAltGKPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.alternateEndpointsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.authenticationCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AuthenticationMechanism (&lctxt, &pvalue->authenticationCapability);
+         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.algorithmOIDsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225GatekeeperRequest_algorithmOIDs (&lctxt, &pvalue->algorithmOIDs);
+         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.integrityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225IntegrityMechanism (&lctxt, &pvalue->integrity);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.supportsAltGKPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperConfirm                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GatekeeperConfirm (OOCTXT* pctxt, H225GatekeeperConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.alternateGatekeeperPresent ||
+   pvalue->m.authenticationModePresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.algorithmOIDPresent ||
+   pvalue->m.integrityPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode rasAddress */
+
+   stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 8);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateGatekeeperPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.authenticationModePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.algorithmOIDPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.alternateGatekeeperPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AlternateGK (&lctxt, &pvalue->alternateGatekeeper);
+         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.authenticationModePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H235AuthenticationMechanism (&lctxt, &pvalue->authenticationMode);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.algorithmOIDPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeObjectIdentifier (&lctxt, &pvalue->algorithmOID);
+         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.integrityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225IntegrityMechanism (&lctxt, &pvalue->integrity);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperRejectReason                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GatekeeperRejectReason (OOCTXT* pctxt, H225GatekeeperRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* resourceUnavailable */
+         case 1:
+            /* NULL */
+            break;
+
+         /* terminalExcluded */
+         case 2:
+            /* NULL */
+            break;
+
+         /* invalidRevision */
+         case 3:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* securityDenial */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericDataReason */
+         case 6:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* neededFeatureNotSupported */
+         case 7:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityError */
+         case 8:
+            stat = asn1PE_H225SecurityErrors (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GatekeeperReject                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225GatekeeperReject (OOCTXT* pctxt, H225GatekeeperReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode rejectReason */
+
+   stat = asn1PE_H225GatekeeperRejectReason (pctxt, &pvalue->rejectReason);
+   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.altGKInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.altGKInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AddressPattern                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225AddressPattern (OOCTXT* pctxt, H225_SeqOfH225AddressPattern* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225AddressPattern (pctxt, ((H225AddressPattern*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225H248PackagesDescriptor                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225H248PackagesDescriptor (OOCTXT* pctxt, H225_SeqOfH225H248PackagesDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H225H248PackagesDescriptor (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRequest                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RegistrationRequest (OOCTXT* pctxt, H225RegistrationRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.alternateEndpointsPresent ||
+   pvalue->m.timeToLivePresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.keepAlivePresent ||
+   pvalue->m.endpointIdentifierPresent ||
+   pvalue->m.willSupplyUUIEsPresent ||
+   pvalue->m.maintainConnectionPresent ||
+   pvalue->m.alternateTransportAddressesPresent ||
+   pvalue->m.additiveRegistrationPresent ||
+   pvalue->m.terminalAliasPatternPresent ||
+   pvalue->m.supportsAltGKPresent ||
+   pvalue->m.usageReportingCapabilityPresent ||
+   pvalue->m.multipleCallsPresent ||
+   pvalue->m.supportedH248PackagesPresent ||
+   pvalue->m.callCreditCapabilityPresent ||
+   pvalue->m.capacityReportingCapabilityPresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent ||
+   pvalue->m.restartPresent ||
+   pvalue->m.supportsACFSequencesPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode discoveryComplete */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->discoveryComplete);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callSignalAddress */
+
+   stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rasAddress */
+
+   stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode terminalType */
+
+   stat = asn1PE_H225EndpointType (pctxt, &pvalue->terminalType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode terminalAlias */
+
+   if (pvalue->m.terminalAliasPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode endpointVendor */
+
+   stat = asn1PE_H225VendorIdentifier (pctxt, &pvalue->endpointVendor);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 22);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.timeToLivePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.keepAlivePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.willSupplyUUIEsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.additiveRegistrationPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPatternPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportsAltGKPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageReportingCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedH248PackagesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callCreditCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityReportingCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.restartPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportsACFSequencesPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.alternateEndpointsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints);
+         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.timeToLivePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225TimeToLive (&lctxt, pvalue->timeToLive);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.keepAlivePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->keepAlive);
+         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.endpointIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225EndpointIdentifier (&lctxt, pvalue->endpointIdentifier);
+         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.willSupplyUUIEsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->willSupplyUUIEs);
+         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.maintainConnectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection);
+         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.alternateTransportAddressesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses);
+         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.additiveRegistrationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.terminalAliasPatternPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AddressPattern (&lctxt, &pvalue->terminalAliasPattern);
+         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.supportsAltGKPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.usageReportingCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225RasUsageInfoTypes (&lctxt, &pvalue->usageReportingCapability);
+         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.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.supportedH248PackagesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225H248PackagesDescriptor (&lctxt, &pvalue->supportedH248Packages);
+         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.callCreditCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCreditCapability (&lctxt, &pvalue->callCreditCapability);
+         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.capacityReportingCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CapacityReportingCapability (&lctxt, &pvalue->capacityReportingCapability);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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.restartPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.supportsACFSequencesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationConfirm_preGrantedARQ                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RegistrationConfirm_preGrantedARQ (OOCTXT* pctxt, H225RegistrationConfirm_preGrantedARQ* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.irrFrequencyInCallPresent ||
+   pvalue->m.totalBandwidthRestrictionPresent ||
+   pvalue->m.alternateTransportAddressesPresent ||
+   pvalue->m.useSpecifiedTransportPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode makeCall */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->makeCall);
+   if (stat != ASN_OK) return stat;
+
+   /* encode useGKCallSignalAddressToMakeCall */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->useGKCallSignalAddressToMakeCall);
+   if (stat != ASN_OK) return stat;
+
+   /* encode answerCall */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->answerCall);
+   if (stat != ASN_OK) return stat;
+
+   /* encode useGKCallSignalAddressToAnswer */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->useGKCallSignalAddressToAnswer);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.irrFrequencyInCallPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.totalBandwidthRestrictionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.useSpecifiedTransportPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.irrFrequencyInCallPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->irrFrequencyInCall, 1U, 65535U);
+         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.totalBandwidthRestrictionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225BandWidth (&lctxt, pvalue->totalBandwidthRestriction);
+         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.alternateTransportAddressesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses);
+         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.useSpecifiedTransportPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225UseSpecifiedTransport (&lctxt, &pvalue->useSpecifiedTransport);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225RasUsageSpecification                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225RasUsageSpecification (OOCTXT* pctxt, H225_SeqOfH225RasUsageSpecification* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225RasUsageSpecification (pctxt, ((H225RasUsageSpecification*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationConfirm                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RegistrationConfirm (OOCTXT* pctxt, H225RegistrationConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.alternateGatekeeperPresent ||
+   pvalue->m.timeToLivePresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.willRespondToIRRPresent ||
+   pvalue->m.preGrantedARQPresent ||
+   pvalue->m.maintainConnectionPresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.supportsAdditiveRegistrationPresent ||
+   pvalue->m.terminalAliasPatternPresent ||
+   pvalue->m.supportedPrefixesPresent ||
+   pvalue->m.usageSpecPresent ||
+   pvalue->m.featureServerAliasPresent ||
+   pvalue->m.capacityReportingSpecPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callSignalAddress */
+
+   stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode terminalAlias */
+
+   if (pvalue->m.terminalAliasPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode endpointIdentifier */
+
+   stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 16);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateGatekeeperPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.timeToLivePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.willRespondToIRRPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.preGrantedARQPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportsAdditiveRegistrationPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPatternPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageSpecPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureServerAliasPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityReportingSpecPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.alternateGatekeeperPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AlternateGK (&lctxt, &pvalue->alternateGatekeeper);
+         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.timeToLivePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225TimeToLive (&lctxt, pvalue->timeToLive);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.willRespondToIRRPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->willRespondToIRR);
+         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.preGrantedARQPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225RegistrationConfirm_preGrantedARQ (&lctxt, &pvalue->preGrantedARQ);
+         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.maintainConnectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection);
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.supportsAdditiveRegistrationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.terminalAliasPatternPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AddressPattern (&lctxt, &pvalue->terminalAliasPattern);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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.usageSpecPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225RasUsageSpecification (&lctxt, &pvalue->usageSpec);
+         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.featureServerAliasPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AliasAddress (&lctxt, &pvalue->featureServerAlias);
+         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.capacityReportingSpecPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CapacityReportingSpecification (&lctxt, &pvalue->capacityReportingSpec);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRejectReason_invalidTerminalAliases           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RegistrationRejectReason_invalidTerminalAliases (OOCTXT* pctxt, H225RegistrationRejectReason_invalidTerminalAliases* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPatternPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+
+   /* encode terminalAlias */
+
+   if (pvalue->m.terminalAliasPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode terminalAliasPattern */
+
+   if (pvalue->m.terminalAliasPatternPresent) {
+      stat = asn1PE_H225_SeqOfH225AddressPattern (pctxt, &pvalue->terminalAliasPattern);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode supportedPrefixes */
+
+   if (pvalue->m.supportedPrefixesPresent) {
+      stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationRejectReason                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RegistrationRejectReason (OOCTXT* pctxt, H225RegistrationRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 8);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* discoveryRequired */
+         case 1:
+            /* NULL */
+            break;
+
+         /* invalidRevision */
+         case 2:
+            /* NULL */
+            break;
+
+         /* invalidCallSignalAddress */
+         case 3:
+            /* NULL */
+            break;
+
+         /* invalidRASAddress */
+         case 4:
+            /* NULL */
+            break;
+
+         /* duplicateAlias */
+         case 5:
+            stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, pvalue->u.duplicateAlias);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* invalidTerminalType */
+         case 6:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 7:
+            /* NULL */
+            break;
+
+         /* transportNotSupported */
+         case 8:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* transportQOSNotSupported */
+         case 9:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* resourceUnavailable */
+         case 10:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* invalidAlias */
+         case 11:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityDenial */
+         case 12:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* fullRegistrationRequired */
+         case 13:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* additiveRegistrationNotSupported */
+         case 14:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* invalidTerminalAliases */
+         case 15:
+            stat = asn1PE_H225RegistrationRejectReason_invalidTerminalAliases (&lctxt, pvalue->u.invalidTerminalAliases);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericDataReason */
+         case 16:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* neededFeatureNotSupported */
+         case 17:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityError */
+         case 18:
+            stat = asn1PE_H225SecurityErrors (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RegistrationReject                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RegistrationReject (OOCTXT* pctxt, H225RegistrationReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode rejectReason */
+
+   stat = asn1PE_H225RegistrationRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode gatekeeperIdentifier */
+
+   if (pvalue->m.gatekeeperIdentifierPresent) {
+      stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier);
+      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.altGKInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.altGKInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregRequestReason                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225UnregRequestReason (OOCTXT* pctxt, H225UnregRequestReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* reregistrationRequired */
+         case 1:
+            /* NULL */
+            break;
+
+         /* ttlExpired */
+         case 2:
+            /* NULL */
+            break;
+
+         /* securityDenial */
+         case 3:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* maintenance */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityError */
+         case 6:
+            stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationRequest                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225UnregistrationRequest (OOCTXT* pctxt, H225UnregistrationRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.alternateEndpointsPresent ||
+   pvalue->m.gatekeeperIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.reasonPresent ||
+   pvalue->m.endpointAliasPatternPresent ||
+   pvalue->m.supportedPrefixesPresent ||
+   pvalue->m.alternateGatekeeperPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointAliasPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callSignalAddress */
+
+   stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointAlias */
+
+   if (pvalue->m.endpointAliasPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode endpointIdentifier */
+
+   if (pvalue->m.endpointIdentifierPresent) {
+      stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 9);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.reasonPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointAliasPatternPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateGatekeeperPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.alternateEndpointsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints);
+         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.gatekeeperIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.reasonPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225UnregRequestReason (&lctxt, &pvalue->reason);
+         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.endpointAliasPatternPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AddressPattern (&lctxt, &pvalue->endpointAliasPattern);
+         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.supportedPrefixesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
+         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.alternateGatekeeperPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AlternateGK (&lctxt, &pvalue->alternateGatekeeper);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationConfirm                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225UnregistrationConfirm (OOCTXT* pctxt, H225UnregistrationConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregRejectReason                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225UnregRejectReason (OOCTXT* pctxt, H225UnregRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* notCurrentlyRegistered */
+         case 1:
+            /* NULL */
+            break;
+
+         /* callInProgress */
+         case 2:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* permissionDenied */
+         case 4:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityDenial */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityError */
+         case 6:
+            stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnregistrationReject                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225UnregistrationReject (OOCTXT* pctxt, H225UnregistrationReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejectReason */
+
+   stat = asn1PE_H225UnregRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.altGKInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CallModel                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225CallModel (OOCTXT* pctxt, H225CallModel* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* direct */
+         case 1:
+            /* NULL */
+            break;
+
+         /* gatekeeperRouted */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportQOS                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225TransportQOS (OOCTXT* pctxt, H225TransportQOS* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* endpointControlled */
+         case 1:
+            /* NULL */
+            break;
+
+         /* gatekeeperControlled */
+         case 2:
+            /* NULL */
+            break;
+
+         /* noControl */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AdmissionRequest (OOCTXT* pctxt, H225AdmissionRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.canMapAliasPresent ||
+   pvalue->m.callIdentifierPresent ||
+   pvalue->m.srcAlternativesPresent ||
+   pvalue->m.destAlternativesPresent ||
+   pvalue->m.gatekeeperIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.transportQOSPresent ||
+   pvalue->m.willSupplyUUIEsPresent ||
+   pvalue->m.callLinkagePresent ||
+   pvalue->m.gatewayDataRatePresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.desiredProtocolsPresent ||
+   pvalue->m.desiredTunnelledProtocolPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent ||
+   pvalue->m.canMapSrcAliasPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callModelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationInfoPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destCallSignalAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.srcCallSignalAddressPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callServicesPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callType */
+
+   stat = asn1PE_H225CallType (pctxt, &pvalue->callType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callModel */
+
+   if (pvalue->m.callModelPresent) {
+      stat = asn1PE_H225CallModel (pctxt, &pvalue->callModel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode endpointIdentifier */
+
+   stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode destinationInfo */
+
+   if (pvalue->m.destinationInfoPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destCallSignalAddress */
+
+   if (pvalue->m.destCallSignalAddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destExtraCallInfo */
+
+   if (pvalue->m.destExtraCallInfoPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode srcInfo */
+
+   stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->srcInfo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode srcCallSignalAddress */
+
+   if (pvalue->m.srcCallSignalAddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->srcCallSignalAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode bandWidth */
+
+   stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callReferenceValue */
+
+   stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callServices */
+
+   if (pvalue->m.callServicesPresent) {
+      stat = asn1PE_H225QseriesOptions (pctxt, &pvalue->callServices);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode conferenceID */
+
+   stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode activeMC */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->activeMC);
+   if (stat != ASN_OK) return stat;
+
+   /* encode answerCall */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->answerCall);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 18);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.canMapAliasPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.srcAlternativesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destAlternativesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportQOSPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.willSupplyUUIEsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatewayDataRatePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredProtocolsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredTunnelledProtocolPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.canMapSrcAliasPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.canMapAliasPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canMapAlias);
+         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.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.srcAlternativesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->srcAlternatives);
+         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.destAlternativesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->destAlternatives);
+         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.gatekeeperIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.transportQOSPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225TransportQOS (&lctxt, &pvalue->transportQOS);
+         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.willSupplyUUIEsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->willSupplyUUIEs);
+         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.callLinkagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage);
+         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.gatewayDataRatePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225DataRate (&lctxt, &pvalue->gatewayDataRate);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.desiredProtocolsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->desiredProtocols);
+         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.desiredTunnelledProtocolPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225TunnelledProtocol (&lctxt, &pvalue->desiredTunnelledProtocol);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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.canMapSrcAliasPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canMapSrcAlias);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UUIEsRequested                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225UUIEsRequested (OOCTXT* pctxt, H225UUIEsRequested* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.statusPresent ||
+   pvalue->m.statusInquiryPresent ||
+   pvalue->m.setupAcknowledgePresent ||
+   pvalue->m.notifyPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode setup */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->setup);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callProceeding */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->callProceeding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode connect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->connect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alerting */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alerting);
+   if (stat != ASN_OK) return stat;
+
+   /* encode information */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->information);
+   if (stat != ASN_OK) return stat;
+
+   /* encode releaseComplete */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->releaseComplete);
+   if (stat != ASN_OK) return stat;
+
+   /* encode facility */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->facility);
+   if (stat != ASN_OK) return stat;
+
+   /* encode progress */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->progress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode empty */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->empty);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.statusPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.statusInquiryPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.setupAcknowledgePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.notifyPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.statusPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->status);
+         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.statusInquiryPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->statusInquiry);
+         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.setupAcknowledgePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->setupAcknowledge);
+         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.notifyPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->notify);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionConfirm_language                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AdmissionConfirm_language (OOCTXT* pctxt, H225AdmissionConfirm_language* pvalue)
+{
+   static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      addSizeConstraint (pctxt, &element_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->elem[xx1], 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AdmissionConfirm (OOCTXT* pctxt, H225AdmissionConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.destinationInfoPresent ||
+   pvalue->m.destExtraCallInfoPresent ||
+   pvalue->m.destinationTypePresent ||
+   pvalue->m.remoteExtensionAddressPresent ||
+   pvalue->m.alternateEndpointsPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.transportQOSPresent ||
+   pvalue->m.willRespondToIRRPresent ||
+   pvalue->m.uuiesRequestedPresent ||
+   pvalue->m.languagePresent ||
+   pvalue->m.alternateTransportAddressesPresent ||
+   pvalue->m.useSpecifiedTransportPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.usageSpecPresent ||
+   pvalue->m.supportedProtocolsPresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.multipleCallsPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent ||
+   pvalue->m.modifiedSrcInfoPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.irrFrequencyPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bandWidth */
+
+   stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callModel */
+
+   stat = asn1PE_H225CallModel (pctxt, &pvalue->callModel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode destCallSignalAddress */
+
+   stat = asn1PE_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode irrFrequency */
+
+   if (pvalue->m.irrFrequencyPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->irrFrequency, 1U, 65535U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 21);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationTypePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportQOSPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.willRespondToIRRPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.uuiesRequestedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.languagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.useSpecifiedTransportPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageSpecPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedProtocolsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.modifiedSrcInfoPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.destinationInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destinationInfo);
+         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.destExtraCallInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destExtraCallInfo);
+         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.destinationTypePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225EndpointType (&lctxt, &pvalue->destinationType);
+         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.remoteExtensionAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->remoteExtensionAddress);
+         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.alternateEndpointsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.transportQOSPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225TransportQOS (&lctxt, &pvalue->transportQOS);
+         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.willRespondToIRRPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->willRespondToIRR);
+         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.uuiesRequestedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225UUIEsRequested (&lctxt, &pvalue->uuiesRequested);
+         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.languagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AdmissionConfirm_language (&lctxt, &pvalue->language);
+         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.alternateTransportAddressesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses);
+         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.useSpecifiedTransportPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225UseSpecifiedTransport (&lctxt, &pvalue->useSpecifiedTransport);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.usageSpecPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225RasUsageSpecification (&lctxt, &pvalue->usageSpec);
+         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.supportedProtocolsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->supportedProtocols);
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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.modifiedSrcInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->modifiedSrcInfo);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225PartyNumber                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225PartyNumber (OOCTXT* pctxt, H225_SeqOfH225PartyNumber* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225PartyNumber (pctxt, ((H225PartyNumber*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionRejectReason                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AdmissionRejectReason (OOCTXT* pctxt, H225AdmissionRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 8);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* calledPartyNotRegistered */
+         case 1:
+            /* NULL */
+            break;
+
+         /* invalidPermission */
+         case 2:
+            /* NULL */
+            break;
+
+         /* requestDenied */
+         case 3:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 4:
+            /* NULL */
+            break;
+
+         /* callerNotRegistered */
+         case 5:
+            /* NULL */
+            break;
+
+         /* routeCallToGatekeeper */
+         case 6:
+            /* NULL */
+            break;
+
+         /* invalidEndpointIdentifier */
+         case 7:
+            /* NULL */
+            break;
+
+         /* resourceUnavailable */
+         case 8:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* securityDenial */
+         case 9:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* qosControlNotSupported */
+         case 10:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* incompleteAddress */
+         case 11:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* aliasesInconsistent */
+         case 12:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* routeCallToSCN */
+         case 13:
+            stat = asn1PE_H225_SeqOfH225PartyNumber (&lctxt, pvalue->u.routeCallToSCN);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* exceedsCallCapacity */
+         case 14:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* collectDestination */
+         case 15:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* collectPIN */
+         case 16:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericDataReason */
+         case 17:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* neededFeatureNotSupported */
+         case 18:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityErrors */
+         case 19:
+            stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityErrors);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityDHmismatch */
+         case 20:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* noRouteToDestination */
+         case 21:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* unallocatedNumber */
+         case 22:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AdmissionReject                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225AdmissionReject (OOCTXT* pctxt, H225AdmissionReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.callSignalAddressPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejectReason */
+
+   stat = asn1PE_H225AdmissionRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callSignalAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.altGKInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.callSignalAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225TransportAddress (&lctxt, &pvalue->callSignalAddress);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225BandwidthDetails                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225BandwidthDetails (OOCTXT* pctxt, H225_SeqOfH225BandwidthDetails* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225BandwidthDetails (pctxt, ((H225BandwidthDetails*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225BandwidthRequest (OOCTXT* pctxt, H225BandwidthRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.gatekeeperIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.answeredCallPresent ||
+   pvalue->m.callLinkagePresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.usageInformationPresent ||
+   pvalue->m.bandwidthDetailsPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callTypePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointIdentifier */
+
+   stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode conferenceID */
+
+   stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callReferenceValue */
+
+   stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callType */
+
+   if (pvalue->m.callTypePresent) {
+      stat = asn1PE_H225CallType (pctxt, &pvalue->callType);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode bandWidth */
+
+   stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 10);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.answeredCallPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInformationPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.bandwidthDetailsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.gatekeeperIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.answeredCallPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->answeredCall);
+         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.callLinkagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.usageInformationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225RasUsageInformation (&lctxt, &pvalue->usageInformation);
+         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.bandwidthDetailsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225BandwidthDetails (&lctxt, &pvalue->bandwidthDetails);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225BandwidthConfirm (OOCTXT* pctxt, H225BandwidthConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bandWidth */
+
+   stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandRejectReason                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225BandRejectReason (OOCTXT* pctxt, H225BandRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* notBound */
+         case 1:
+            /* NULL */
+            break;
+
+         /* invalidConferenceID */
+         case 2:
+            /* NULL */
+            break;
+
+         /* invalidPermission */
+         case 3:
+            /* NULL */
+            break;
+
+         /* insufficientResources */
+         case 4:
+            /* NULL */
+            break;
+
+         /* invalidRevision */
+         case 5:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 6:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* securityDenial */
+         case 7:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityError */
+         case 8:
+            stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BandwidthReject                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225BandwidthReject (OOCTXT* pctxt, H225BandwidthReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejectReason */
+
+   stat = asn1PE_H225BandRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode allowedBandWidth */
+
+   stat = asn1PE_H225BandWidth (pctxt, pvalue->allowedBandWidth);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.altGKInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageReason                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225DisengageReason (OOCTXT* pctxt, H225DisengageReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* forcedDrop */
+         case 1:
+            /* NULL */
+            break;
+
+         /* normalDrop */
+         case 2:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225DisengageRequest (OOCTXT* pctxt, H225DisengageRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.gatekeeperIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.answeredCallPresent ||
+   pvalue->m.callLinkagePresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.usageInformationPresent ||
+   pvalue->m.terminationCausePresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointIdentifier */
+
+   stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode conferenceID */
+
+   stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callReferenceValue */
+
+   stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   /* encode disengageReason */
+
+   stat = asn1PE_H225DisengageReason (pctxt, &pvalue->disengageReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 12);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.answeredCallPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInformationPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminationCausePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.gatekeeperIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.answeredCallPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->answeredCall);
+         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.callLinkagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.usageInformationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225RasUsageInformation (&lctxt, &pvalue->usageInformation);
+         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.terminationCausePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallTerminationCause (&lctxt, &pvalue->terminationCause);
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageConfirm                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225DisengageConfirm (OOCTXT* pctxt, H225DisengageConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.usageInformationPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInformationPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.usageInformationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225RasUsageInformation (&lctxt, &pvalue->usageInformation);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageRejectReason                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225DisengageRejectReason (OOCTXT* pctxt, H225DisengageRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* notRegistered */
+         case 1:
+            /* NULL */
+            break;
+
+         /* requestToDropOther */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* securityDenial */
+         case 3:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityError */
+         case 4:
+            stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DisengageReject                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225DisengageReject (OOCTXT* pctxt, H225DisengageReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejectReason */
+
+   stat = asn1PE_H225DisengageRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.altGKInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LocationRequest                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225LocationRequest (OOCTXT* pctxt, H225LocationRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.sourceInfoPresent ||
+   pvalue->m.canMapAliasPresent ||
+   pvalue->m.gatekeeperIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.desiredProtocolsPresent ||
+   pvalue->m.desiredTunnelledProtocolPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent ||
+   pvalue->m.hopCountPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.callIdentifierPresent ||
+   pvalue->m.bandWidthPresent ||
+   pvalue->m.sourceEndpointInfoPresent ||
+   pvalue->m.canMapSrcAliasPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointIdentifier */
+
+   if (pvalue->m.endpointIdentifierPresent) {
+      stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destinationInfo */
+
+   stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode replyAddress */
+
+   stat = asn1PE_H225TransportAddress (pctxt, &pvalue->replyAddress);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 15);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.canMapAliasPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredProtocolsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredTunnelledProtocolPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.hopCountPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.bandWidthPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceEndpointInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.canMapSrcAliasPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.sourceInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->sourceInfo);
+         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.canMapAliasPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canMapAlias);
+         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.gatekeeperIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.desiredProtocolsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->desiredProtocols);
+         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.desiredTunnelledProtocolPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225TunnelledProtocol (&lctxt, &pvalue->desiredTunnelledProtocol);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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.hopCountPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->hopCount, 1U, 255U);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.bandWidthPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225BandWidth (&lctxt, pvalue->bandWidth);
+         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.sourceEndpointInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->sourceEndpointInfo);
+         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.canMapSrcAliasPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canMapSrcAlias);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LocationConfirm                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225LocationConfirm (OOCTXT* pctxt, H225LocationConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.destinationInfoPresent ||
+   pvalue->m.destExtraCallInfoPresent ||
+   pvalue->m.destinationTypePresent ||
+   pvalue->m.remoteExtensionAddressPresent ||
+   pvalue->m.alternateEndpointsPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.alternateTransportAddressesPresent ||
+   pvalue->m.supportedProtocolsPresent ||
+   pvalue->m.multipleCallsPresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent ||
+   pvalue->m.circuitInfoPresent ||
+   pvalue->m.serviceControlPresent ||
+   pvalue->m.modifiedSrcInfoPresent ||
+   pvalue->m.bandWidthPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callSignalAddress */
+
+   stat = asn1PE_H225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rasAddress */
+
+   stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 16);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationTypePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedProtocolsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.modifiedSrcInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.bandWidthPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.destinationInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destinationInfo);
+         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.destExtraCallInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destExtraCallInfo);
+         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.destinationTypePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225EndpointType (&lctxt, &pvalue->destinationType);
+         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.remoteExtensionAddressPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->remoteExtensionAddress);
+         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.alternateEndpointsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.alternateTransportAddressesPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses);
+         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.supportedProtocolsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->supportedProtocols);
+         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.multipleCallsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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.modifiedSrcInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->modifiedSrcInfo);
+         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.bandWidthPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225BandWidth (&lctxt, pvalue->bandWidth);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LocationRejectReason                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225LocationRejectReason (OOCTXT* pctxt, H225LocationRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* notRegistered */
+         case 1:
+            /* NULL */
+            break;
+
+         /* invalidPermission */
+         case 2:
+            /* NULL */
+            break;
+
+         /* requestDenied */
+         case 3:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* securityDenial */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* aliasesInconsistent */
+         case 6:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* routeCalltoSCN */
+         case 7:
+            stat = asn1PE_H225_SeqOfH225PartyNumber (&lctxt, pvalue->u.routeCalltoSCN);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* resourceUnavailable */
+         case 8:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericDataReason */
+         case 9:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* neededFeatureNotSupported */
+         case 10:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* hopCountExceeded */
+         case 11:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* incompleteAddress */
+         case 12:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityError */
+         case 13:
+            stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* securityDHmismatch */
+         case 14:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* noRouteToDestination */
+         case 15:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* unallocatedNumber */
+         case 16:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LocationReject                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225LocationReject (OOCTXT* pctxt, H225LocationReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent ||
+   pvalue->m.serviceControlPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejectReason */
+
+   stat = asn1PE_H225LocationRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.altGKInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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.serviceControlPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequest                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225InfoRequest (OOCTXT* pctxt, H225InfoRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.uuiesRequestedPresent ||
+   pvalue->m.callLinkagePresent ||
+   pvalue->m.usageInfoRequestedPresent ||
+   pvalue->m.segmentedResponseSupportedPresent ||
+   pvalue->m.nextSegmentRequestedPresent ||
+   pvalue->m.capacityInfoRequestedPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.replyAddressPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callReferenceValue */
+
+   stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode replyAddress */
+
+   if (pvalue->m.replyAddressPresent) {
+      stat = asn1PE_H225TransportAddress (pctxt, &pvalue->replyAddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 10);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.uuiesRequestedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInfoRequestedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.segmentedResponseSupportedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.nextSegmentRequestedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityInfoRequestedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.uuiesRequestedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225UUIEsRequested (&lctxt, &pvalue->uuiesRequested);
+         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.callLinkagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage);
+         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.usageInfoRequestedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225RasUsageInfoTypes (&lctxt, &pvalue->usageInfoRequested);
+         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.segmentedResponseSupportedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.nextSegmentRequestedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->nextSegmentRequested, 0U, 65535U);
+         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.capacityInfoRequestedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225RTPSession                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225RTPSession (OOCTXT* pctxt, H225_SeqOfH225RTPSession* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225RTPSession (pctxt, ((H225RTPSession*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225TransportChannelInfo                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225TransportChannelInfo (OOCTXT* pctxt, H225_SeqOfH225TransportChannelInfo* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225TransportChannelInfo (pctxt, ((H225TransportChannelInfo*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225ConferenceIdentifier                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225ConferenceIdentifier (OOCTXT* pctxt, H225_SeqOfH225ConferenceIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse_perCallInfo_element_pdu_element       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode h323pdu */
+
+   stat = asn1PE_H225H323_UU_PDU (pctxt, &pvalue->h323pdu);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sent */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->sent);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_el  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225InfoRequestResponse_perCallInfo_element_pdu_element (pctxt, ((H225InfoRequestResponse_perCallInfo_element_pdu_element*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse_perCallInfo_element                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent ||
+   pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.substituteConfIDsPresent ||
+   pvalue->m.pduPresent ||
+   pvalue->m.callLinkagePresent ||
+   pvalue->m.usageInformationPresent ||
+   pvalue->m.circuitInfoPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.originatorPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.audioPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callReferenceValue */
+
+   stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue);
+   if (stat != ASN_OK) return stat;
+
+   /* encode conferenceID */
+
+   stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode originator */
+
+   if (pvalue->m.originatorPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->originator);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode audio */
+
+   if (pvalue->m.audioPresent) {
+      stat = asn1PE_H225_SeqOfH225RTPSession (pctxt, &pvalue->audio);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode video */
+
+   if (pvalue->m.videoPresent) {
+      stat = asn1PE_H225_SeqOfH225RTPSession (pctxt, &pvalue->video);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode data */
+
+   if (pvalue->m.dataPresent) {
+      stat = asn1PE_H225_SeqOfH225TransportChannelInfo (pctxt, &pvalue->data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode h245 */
+
+   stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->h245);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callSignaling */
+
+   stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->callSignaling);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callType */
+
+   stat = asn1PE_H225CallType (pctxt, &pvalue->callType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bandWidth */
+
+   stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callModel */
+
+   stat = asn1PE_H225CallModel (pctxt, &pvalue->callModel);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.substituteConfIDsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.pduPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInformationPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.callIdentifierPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier);
+         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.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.substituteConfIDsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ConferenceIdentifier (&lctxt, &pvalue->substituteConfIDs);
+         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.pduPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (&lctxt, &pvalue->pdu);
+         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.callLinkagePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage);
+         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.usageInformationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225RasUsageInformation (&lctxt, &pvalue->usageInformation);
+         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.circuitInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225InfoRequestResponse_perCallInfo_element         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225InfoRequestResponse_perCallInfo_element (pctxt, ((H225InfoRequestResponse_perCallInfo_element*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponseStatus                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225InfoRequestResponseStatus (OOCTXT* pctxt, H225InfoRequestResponseStatus* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* complete */
+         case 1:
+            /* NULL */
+            break;
+
+         /* incomplete */
+         case 2:
+            /* NULL */
+            break;
+
+         /* segment */
+         case 3:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.segment, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* invalidCall */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestResponse                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225InfoRequestResponse (OOCTXT* pctxt, H225InfoRequestResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.needResponsePresent ||
+   pvalue->m.capacityPresent ||
+   pvalue->m.irrStatusPresent ||
+   pvalue->m.unsolicitedPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointAliasPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.perCallInfoPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointType */
+
+   stat = asn1PE_H225EndpointType (pctxt, &pvalue->endpointType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointIdentifier */
+
+   stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rasAddress */
+
+   stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callSignalAddress */
+
+   stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointAlias */
+
+   if (pvalue->m.endpointAliasPresent) {
+      stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode perCallInfo */
+
+   if (pvalue->m.perCallInfoPresent) {
+      stat = asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (pctxt, &pvalue->perCallInfo);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.needResponsePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.irrStatusPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.unsolicitedPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.needResponsePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->needResponse);
+         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.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.irrStatusPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225InfoRequestResponseStatus (&lctxt, &pvalue->irrStatus);
+         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.unsolicitedPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->unsolicited);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardMessage                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225NonStandardMessage (OOCTXT* pctxt, H225NonStandardMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.featureSetPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.featureSetPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnknownMessageResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225UnknownMessageResponse (OOCTXT* pctxt, H225UnknownMessageResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.tokensPresent ||
+   pvalue->m.cryptoTokensPresent ||
+   pvalue->m.integrityCheckValuePresent ||
+   pvalue->m.messageNotUnderstoodPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.messageNotUnderstoodPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.tokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens);
+         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.cryptoTokensPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens);
+         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.integrityCheckValuePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue);
+         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.messageNotUnderstoodPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeOctetString (&lctxt, pvalue->messageNotUnderstood.numocts, pvalue->messageNotUnderstood.data);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestInProgress                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RequestInProgress (OOCTXT* pctxt, H225RequestInProgress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode delay */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->delay, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ResourcesAvailableIndicate                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ResourcesAvailableIndicate (OOCTXT* pctxt, H225ResourcesAvailableIndicate* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.capacityPresent ||
+   pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode endpointIdentifier */
+
+   stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocols */
+
+   stat = asn1PE_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocols);
+   if (stat != ASN_OK) return stat;
+
+   /* encode almostOutOfResources */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->almostOutOfResources);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.capacityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity);
+         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.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ResourcesAvailableConfirm                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ResourcesAvailableConfirm (OOCTXT* pctxt, H225ResourcesAvailableConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.genericDataPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      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.genericDataPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.genericDataPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestAck                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225InfoRequestAck (OOCTXT* pctxt, H225InfoRequestAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestNakReason                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225InfoRequestNakReason (OOCTXT* pctxt, H225InfoRequestNakReason* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* notRegistered */
+         case 1:
+            /* NULL */
+            break;
+
+         /* securityDenial */
+         case 2:
+            /* NULL */
+            break;
+
+         /* undefinedReason */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* securityError */
+         case 4:
+            stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  InfoRequestNak                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225InfoRequestNak (OOCTXT* pctxt, H225InfoRequestNak* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode nakReason */
+
+   stat = asn1PE_H225InfoRequestNakReason (pctxt, &pvalue->nakReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode altGKInfo */
+
+   if (pvalue->m.altGKInfoPresent) {
+      stat = asn1PE_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlIndication_callSpecific                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ServiceControlIndication_callSpecific (OOCTXT* pctxt, H225ServiceControlIndication_callSpecific* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode callIdentifier */
+
+   stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode conferenceID */
+
+   stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode answeredCall */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->answeredCall);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlIndication                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ServiceControlIndication (OOCTXT* pctxt, H225ServiceControlIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.callSpecificPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode serviceControl */
+
+   stat = asn1PE_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
+   if (stat != ASN_OK) return stat;
+
+   /* encode endpointIdentifier */
+
+   if (pvalue->m.endpointIdentifierPresent) {
+      stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode callSpecific */
+
+   if (pvalue->m.callSpecificPresent) {
+      stat = asn1PE_H225ServiceControlIndication_callSpecific (pctxt, &pvalue->callSpecific);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode featureSet */
+
+   if (pvalue->m.featureSetPresent) {
+      stat = asn1PE_H225FeatureSet (pctxt, &pvalue->featureSet);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode genericData */
+
+   if (pvalue->m.genericDataPresent) {
+      stat = asn1PE_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlResponse_result                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ServiceControlResponse_result (OOCTXT* pctxt, H225ServiceControlResponse_result* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* started */
+         case 1:
+            /* NULL */
+            break;
+
+         /* failed */
+         case 2:
+            /* NULL */
+            break;
+
+         /* stopped */
+         case 3:
+            /* NULL */
+            break;
+
+         /* notAvailable */
+         case 4:
+            /* NULL */
+            break;
+
+         /* neededFeatureNotSupported */
+         case 5:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ServiceControlResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225ServiceControlResponse (OOCTXT* pctxt, H225ServiceControlResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.resultPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent);
+
+   /* encode requestSeqNum */
+
+   stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode result */
+
+   if (pvalue->m.resultPresent) {
+      stat = asn1PE_H225ServiceControlResponse_result (pctxt, &pvalue->result);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokens */
+
+   if (pvalue->m.tokensPresent) {
+      stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode cryptoTokens */
+
+   if (pvalue->m.cryptoTokensPresent) {
+      stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode integrityCheckValue */
+
+   if (pvalue->m.integrityCheckValuePresent) {
+      stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode featureSet */
+
+   if (pvalue->m.featureSetPresent) {
+      stat = asn1PE_H225FeatureSet (pctxt, &pvalue->featureSet);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode genericData */
+
+   if (pvalue->m.genericDataPresent) {
+      stat = asn1PE_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH225AdmissionConfirm                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225_SeqOfH225AdmissionConfirm (OOCTXT* pctxt, H225_SeqOfH225AdmissionConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H225AdmissionConfirm (pctxt, ((H225AdmissionConfirm*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RasMessage                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H225RasMessage (OOCTXT* pctxt, H225RasMessage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 25);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 24);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* gatekeeperRequest */
+         case 1:
+            stat = asn1PE_H225GatekeeperRequest (pctxt, pvalue->u.gatekeeperRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* gatekeeperConfirm */
+         case 2:
+            stat = asn1PE_H225GatekeeperConfirm (pctxt, pvalue->u.gatekeeperConfirm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* gatekeeperReject */
+         case 3:
+            stat = asn1PE_H225GatekeeperReject (pctxt, pvalue->u.gatekeeperReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* registrationRequest */
+         case 4:
+            stat = asn1PE_H225RegistrationRequest (pctxt, pvalue->u.registrationRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* registrationConfirm */
+         case 5:
+            stat = asn1PE_H225RegistrationConfirm (pctxt, pvalue->u.registrationConfirm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* registrationReject */
+         case 6:
+            stat = asn1PE_H225RegistrationReject (pctxt, pvalue->u.registrationReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* unregistrationRequest */
+         case 7:
+            stat = asn1PE_H225UnregistrationRequest (pctxt, pvalue->u.unregistrationRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* unregistrationConfirm */
+         case 8:
+            stat = asn1PE_H225UnregistrationConfirm (pctxt, pvalue->u.unregistrationConfirm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* unregistrationReject */
+         case 9:
+            stat = asn1PE_H225UnregistrationReject (pctxt, pvalue->u.unregistrationReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* admissionRequest */
+         case 10:
+            stat = asn1PE_H225AdmissionRequest (pctxt, pvalue->u.admissionRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* admissionConfirm */
+         case 11:
+            stat = asn1PE_H225AdmissionConfirm (pctxt, pvalue->u.admissionConfirm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* admissionReject */
+         case 12:
+            stat = asn1PE_H225AdmissionReject (pctxt, pvalue->u.admissionReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* bandwidthRequest */
+         case 13:
+            stat = asn1PE_H225BandwidthRequest (pctxt, pvalue->u.bandwidthRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* bandwidthConfirm */
+         case 14:
+            stat = asn1PE_H225BandwidthConfirm (pctxt, pvalue->u.bandwidthConfirm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* bandwidthReject */
+         case 15:
+            stat = asn1PE_H225BandwidthReject (pctxt, pvalue->u.bandwidthReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* disengageRequest */
+         case 16:
+            stat = asn1PE_H225DisengageRequest (pctxt, pvalue->u.disengageRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* disengageConfirm */
+         case 17:
+            stat = asn1PE_H225DisengageConfirm (pctxt, pvalue->u.disengageConfirm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* disengageReject */
+         case 18:
+            stat = asn1PE_H225DisengageReject (pctxt, pvalue->u.disengageReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* locationRequest */
+         case 19:
+            stat = asn1PE_H225LocationRequest (pctxt, pvalue->u.locationRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* locationConfirm */
+         case 20:
+            stat = asn1PE_H225LocationConfirm (pctxt, pvalue->u.locationConfirm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* locationReject */
+         case 21:
+            stat = asn1PE_H225LocationReject (pctxt, pvalue->u.locationReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* infoRequest */
+         case 22:
+            stat = asn1PE_H225InfoRequest (pctxt, pvalue->u.infoRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* infoRequestResponse */
+         case 23:
+            stat = asn1PE_H225InfoRequestResponse (pctxt, pvalue->u.infoRequestResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nonStandardMessage */
+         case 24:
+            stat = asn1PE_H225NonStandardMessage (pctxt, pvalue->u.nonStandardMessage);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* unknownMessageResponse */
+         case 25:
+            stat = asn1PE_H225UnknownMessageResponse (pctxt, pvalue->u.unknownMessageResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 26);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* requestInProgress */
+         case 26:
+            stat = asn1PE_H225RequestInProgress (&lctxt, pvalue->u.requestInProgress);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* resourcesAvailableIndicate */
+         case 27:
+            stat = asn1PE_H225ResourcesAvailableIndicate (&lctxt, pvalue->u.resourcesAvailableIndicate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* resourcesAvailableConfirm */
+         case 28:
+            stat = asn1PE_H225ResourcesAvailableConfirm (&lctxt, pvalue->u.resourcesAvailableConfirm);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* infoRequestAck */
+         case 29:
+            stat = asn1PE_H225InfoRequestAck (&lctxt, pvalue->u.infoRequestAck);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* infoRequestNak */
+         case 30:
+            stat = asn1PE_H225InfoRequestNak (&lctxt, pvalue->u.infoRequestNak);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* serviceControlIndication */
+         case 31:
+            stat = asn1PE_H225ServiceControlIndication (&lctxt, pvalue->u.serviceControlIndication);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* serviceControlResponse */
+         case 32:
+            stat = asn1PE_H225ServiceControlResponse (&lctxt, pvalue->u.serviceControlResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* admissionConfirmSequence */
+         case 33:
+            stat = asn1PE_H225_SeqOfH225AdmissionConfirm (&lctxt, pvalue->u.admissionConfirmSequence);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
diff --git a/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.c b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.c
new file mode 100644
index 000000000..ca69407a6
--- /dev/null
+++ b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#include "ooasn1.h"
+#include "MULTIMEDIA-SYSTEM-CONTROL.h"
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_networkAddress                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet =
+"#*,0123456789";
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signal                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet =
+"!#*0123456789ABCD";
+
diff --git a/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.h b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.h
new file mode 100644
index 000000000..6923cba5a
--- /dev/null
+++ b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.h
@@ -0,0 +1,10937 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#ifndef MULTIMEDIA_SYSTEM_CONTROL_H
+#define MULTIMEDIA_SYSTEM_CONTROL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ooasn1.h"
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier_h221NonStandard                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NonStandardIdentifier_h221NonStandard {
+   ASN1UINT8 t35CountryCode;
+   ASN1UINT8 t35Extension;
+   ASN1USINT manufacturerCode;
+} H245NonStandardIdentifier_h221NonStandard;
+
+EXTERN int asn1PE_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue);
+
+EXTERN int asn1PD_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NonStandardIdentifier_object 1
+#define T_H245NonStandardIdentifier_h221NonStandard 2
+
+typedef struct EXTERN H245NonStandardIdentifier {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1OBJID *object;
+      /* t = 2 */
+      H245NonStandardIdentifier_h221NonStandard *h221NonStandard;
+   } u;
+} H245NonStandardIdentifier;
+
+EXTERN int asn1PE_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* pvalue);
+
+EXTERN int asn1PD_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NonStandardParameter {
+   H245NonStandardIdentifier nonStandardIdentifier;
+   ASN1DynOctStr data;
+} H245NonStandardParameter;
+
+EXTERN int asn1PE_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue);
+
+EXTERN int asn1PD_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V42bis                                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245V42bis {
+   ASN1UINT numberOfCodewords;
+   ASN1USINT maximumStringLength;
+} H245V42bis;
+
+EXTERN int asn1PE_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue);
+
+EXTERN int asn1PD_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CompressionType                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CompressionType_v42bis    1
+#define T_H245CompressionType_extElem1  2
+
+typedef struct EXTERN H245CompressionType {
+   int t;
+   union {
+      /* t = 1 */
+      H245V42bis *v42bis;
+      /* t = 2 */
+   } u;
+} H245CompressionType;
+
+EXTERN int asn1PE_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue);
+
+EXTERN int asn1PD_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataProtocolCapability_v76wCompression                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245DataProtocolCapability_v76wCompression_transmitCompression 1
+#define T_H245DataProtocolCapability_v76wCompression_receiveCompression 2
+#define T_H245DataProtocolCapability_v76wCompression_transmitAndReceiveCompression 3
+#define T_H245DataProtocolCapability_v76wCompression_extElem1 4
+
+typedef struct EXTERN H245DataProtocolCapability_v76wCompression {
+   int t;
+   union {
+      /* t = 1 */
+      H245CompressionType *transmitCompression;
+      /* t = 2 */
+      H245CompressionType *receiveCompression;
+      /* t = 3 */
+      H245CompressionType *transmitAndReceiveCompression;
+      /* t = 4 */
+   } u;
+} H245DataProtocolCapability_v76wCompression;
+
+EXTERN int asn1PE_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue);
+
+EXTERN int asn1PD_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataProtocolCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245DataProtocolCapability_nonStandard 1
+#define T_H245DataProtocolCapability_v14buffered 2
+#define T_H245DataProtocolCapability_v42lapm 3
+#define T_H245DataProtocolCapability_hdlcFrameTunnelling 4
+#define T_H245DataProtocolCapability_h310SeparateVCStack 5
+#define T_H245DataProtocolCapability_h310SingleVCStack 6
+#define T_H245DataProtocolCapability_transparent 7
+#define T_H245DataProtocolCapability_segmentationAndReassembly 8
+#define T_H245DataProtocolCapability_hdlcFrameTunnelingwSAR 9
+#define T_H245DataProtocolCapability_v120 10
+#define T_H245DataProtocolCapability_separateLANStack 11
+#define T_H245DataProtocolCapability_v76wCompression 12
+#define T_H245DataProtocolCapability_tcp 13
+#define T_H245DataProtocolCapability_udp 14
+#define T_H245DataProtocolCapability_extElem1 15
+
+typedef struct EXTERN H245DataProtocolCapability {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      /* t = 9 */
+      /* t = 10 */
+      /* t = 11 */
+      /* t = 12 */
+      H245DataProtocolCapability_v76wCompression *v76wCompression;
+      /* t = 13 */
+      /* t = 14 */
+      /* t = 15 */
+   } u;
+} H245DataProtocolCapability;
+
+EXTERN int asn1PE_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue);
+
+EXTERN int asn1PD_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxRateManagement                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245T38FaxRateManagement_localTCF 1
+#define T_H245T38FaxRateManagement_transferredTCF 2
+#define T_H245T38FaxRateManagement_extElem1 3
+
+typedef struct EXTERN H245T38FaxRateManagement {
+   int t;
+} H245T38FaxRateManagement;
+
+EXTERN int asn1PE_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue);
+
+EXTERN int asn1PD_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxUdpOptions_t38FaxUdpEC                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245T38FaxUdpOptions_t38FaxUdpEC_t38UDPFEC 1
+#define T_H245T38FaxUdpOptions_t38FaxUdpEC_t38UDPRedundancy 2
+#define T_H245T38FaxUdpOptions_t38FaxUdpEC_extElem1 3
+
+typedef struct EXTERN H245T38FaxUdpOptions_t38FaxUdpEC {
+   int t;
+} H245T38FaxUdpOptions_t38FaxUdpEC;
+
+EXTERN int asn1PE_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue);
+
+EXTERN int asn1PD_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxUdpOptions                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245T38FaxUdpOptions {
+   struct {
+      unsigned t38FaxMaxBufferPresent : 1;
+      unsigned t38FaxMaxDatagramPresent : 1;
+   } m;
+   ASN1INT t38FaxMaxBuffer;
+   ASN1INT t38FaxMaxDatagram;
+   H245T38FaxUdpOptions_t38FaxUdpEC t38FaxUdpEC;
+} H245T38FaxUdpOptions;
+
+EXTERN int asn1PE_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue);
+
+EXTERN int asn1PD_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxTcpOptions                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245T38FaxTcpOptions {
+   ASN1BOOL t38TCPBidirectionalMode;
+} H245T38FaxTcpOptions;
+
+EXTERN int asn1PE_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue);
+
+EXTERN int asn1PD_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxProfile                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245T38FaxProfile {
+   struct {
+      unsigned versionPresent : 1;
+      unsigned t38FaxRateManagementPresent : 1;
+      unsigned t38FaxUdpOptionsPresent : 1;
+      unsigned t38FaxTcpOptionsPresent : 1;
+   } m;
+   ASN1BOOL fillBitRemoval;
+   ASN1BOOL transcodingJBIG;
+   ASN1BOOL transcodingMMR;
+   ASN1UINT8 version;
+   H245T38FaxRateManagement t38FaxRateManagement;
+   H245T38FaxUdpOptions t38FaxUdpOptions;
+   H245T38FaxTcpOptions t38FaxTcpOptions;
+} H245T38FaxProfile;
+
+EXTERN int asn1PE_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue);
+
+EXTERN int asn1PD_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardMessage                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NonStandardMessage {
+   H245NonStandardParameter nonStandardData;
+} H245NonStandardMessage;
+
+EXTERN int asn1PE_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue);
+
+EXTERN int asn1PD_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDetermination                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MasterSlaveDetermination {
+   ASN1UINT8 terminalType;
+   ASN1UINT statusDeterminationNumber;
+} H245MasterSlaveDetermination;
+
+EXTERN int asn1PE_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue);
+
+EXTERN int asn1PD_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SequenceNumber                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT8 H245SequenceNumber;
+
+EXTERN int asn1PE_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber value);
+
+EXTERN int asn1PD_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VCCapability_aal1 {
+   ASN1BOOL nullClockRecovery;
+   ASN1BOOL srtsClockRecovery;
+   ASN1BOOL adaptiveClockRecovery;
+   ASN1BOOL nullErrorCorrection;
+   ASN1BOOL longInterleaver;
+   ASN1BOOL shortInterleaver;
+   ASN1BOOL errorCorrectionOnly;
+   ASN1BOOL structuredDataTransfer;
+   ASN1BOOL partiallyFilledCells;
+} H245VCCapability_aal1;
+
+EXTERN int asn1PE_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue);
+
+EXTERN int asn1PD_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal5                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VCCapability_aal5 {
+   ASN1USINT forwardMaximumSDUSize;
+   ASN1USINT backwardMaximumSDUSize;
+} H245VCCapability_aal5;
+
+EXTERN int asn1PE_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue);
+
+EXTERN int asn1PD_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates_type_rangeOfBitRates       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VCCapability_availableBitRates_type_rangeOfBitRates {
+   ASN1USINT lowerBitRate;
+   ASN1USINT higherBitRate;
+} H245VCCapability_availableBitRates_type_rangeOfBitRates;
+
+EXTERN int asn1PE_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue);
+
+EXTERN int asn1PD_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates_type                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245VCCapability_availableBitRates_type_singleBitRate 1
+#define T_H245VCCapability_availableBitRates_type_rangeOfBitRates 2
+
+typedef struct EXTERN H245VCCapability_availableBitRates_type {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1USINT singleBitRate;
+      /* t = 2 */
+      H245VCCapability_availableBitRates_type_rangeOfBitRates *rangeOfBitRates;
+   } u;
+} H245VCCapability_availableBitRates_type;
+
+EXTERN int asn1PE_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* pvalue);
+
+EXTERN int asn1PD_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VCCapability_availableBitRates {
+   H245VCCapability_availableBitRates_type type;
+} H245VCCapability_availableBitRates;
+
+EXTERN int asn1PE_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue);
+
+EXTERN int asn1PD_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_address_nsapAddress                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245Q2931Address_address_nsapAddress {
+   ASN1UINT numocts;
+   ASN1OCTET data[20];
+} H245Q2931Address_address_nsapAddress;
+
+EXTERN int asn1PE_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* pvalue);
+
+EXTERN int asn1PD_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_address                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245Q2931Address_address_internationalNumber 1
+#define T_H245Q2931Address_address_nsapAddress 2
+#define T_H245Q2931Address_address_extElem1 3
+
+typedef struct EXTERN H245Q2931Address_address {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1NumericString internationalNumber;
+      /* t = 2 */
+      H245Q2931Address_address_nsapAddress *nsapAddress;
+      /* t = 3 */
+   } u;
+} H245Q2931Address_address;
+
+EXTERN int asn1PE_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue);
+
+EXTERN int asn1PD_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_subaddress                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245Q2931Address_subaddress {
+   ASN1UINT numocts;
+   ASN1OCTET data[20];
+} H245Q2931Address_subaddress;
+
+EXTERN int asn1PE_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* pvalue);
+
+EXTERN int asn1PD_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245Q2931Address {
+   struct {
+      unsigned subaddressPresent : 1;
+   } m;
+   H245Q2931Address_address address;
+   H245Q2931Address_subaddress subaddress;
+} H245Q2931Address;
+
+EXTERN int asn1PE_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue);
+
+EXTERN int asn1PD_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1ViaGateway_gatewayAddress                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245Q2931Address */
+typedef DList H245VCCapability_aal1ViaGateway_gatewayAddress;
+
+EXTERN int asn1PE_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue);
+
+EXTERN int asn1PD_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1ViaGateway                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VCCapability_aal1ViaGateway {
+   H245VCCapability_aal1ViaGateway_gatewayAddress gatewayAddress;
+   ASN1BOOL nullClockRecovery;
+   ASN1BOOL srtsClockRecovery;
+   ASN1BOOL adaptiveClockRecovery;
+   ASN1BOOL nullErrorCorrection;
+   ASN1BOOL longInterleaver;
+   ASN1BOOL shortInterleaver;
+   ASN1BOOL errorCorrectionOnly;
+   ASN1BOOL structuredDataTransfer;
+   ASN1BOOL partiallyFilledCells;
+} H245VCCapability_aal1ViaGateway;
+
+EXTERN int asn1PE_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue);
+
+EXTERN int asn1PD_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VCCapability {
+   struct {
+      unsigned aal1Present : 1;
+      unsigned aal5Present : 1;
+      unsigned aal1ViaGatewayPresent : 1;
+   } m;
+   H245VCCapability_aal1 aal1;
+   H245VCCapability_aal5 aal5;
+   ASN1BOOL transportStream;
+   ASN1BOOL programStream;
+   H245VCCapability_availableBitRates availableBitRates;
+   H245VCCapability_aal1ViaGateway aal1ViaGateway;
+} H245VCCapability;
+
+EXTERN int asn1PE_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue);
+
+EXTERN int asn1PD_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SetOfH245VCCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245VCCapability */
+typedef DList H245_SetOfH245VCCapability;
+
+EXTERN int asn1PE_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue);
+
+EXTERN int asn1PD_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H222Capability                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H222Capability {
+   ASN1USINT numberOfVCs;
+   H245_SetOfH245VCCapability vcCapability;
+} H245H222Capability;
+
+EXTERN int asn1PE_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue);
+
+EXTERN int asn1PD_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_h223MultiplexTableCapability_enhanced      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223Capability_h223MultiplexTableCapability_enhanced {
+   ASN1UINT8 maximumNestingDepth;
+   ASN1UINT8 maximumElementListSize;
+   ASN1UINT8 maximumSubElementListSize;
+} H245H223Capability_h223MultiplexTableCapability_enhanced;
+
+EXTERN int asn1PE_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue);
+
+EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_h223MultiplexTableCapability               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223Capability_h223MultiplexTableCapability_basic 1
+#define T_H245H223Capability_h223MultiplexTableCapability_enhanced 2
+
+typedef struct EXTERN H245H223Capability_h223MultiplexTableCapability {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245H223Capability_h223MultiplexTableCapability_enhanced *enhanced;
+   } u;
+} H245H223Capability_h223MultiplexTableCapability;
+
+EXTERN int asn1PE_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue);
+
+EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_mobileOperationTransmitCapability          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223Capability_mobileOperationTransmitCapability {
+   ASN1BOOL modeChangeCapability;
+   ASN1BOOL h223AnnexA;
+   ASN1BOOL h223AnnexADoubleFlag;
+   ASN1BOOL h223AnnexB;
+   ASN1BOOL h223AnnexBwithHeader;
+} H245H223Capability_mobileOperationTransmitCapability;
+
+EXTERN int asn1PE_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue);
+
+EXTERN int asn1PD_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AnnexCCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223AnnexCCapability {
+   struct {
+      unsigned rsCodeCapabilityPresent : 1;
+   } m;
+   ASN1BOOL videoWithAL1M;
+   ASN1BOOL videoWithAL2M;
+   ASN1BOOL videoWithAL3M;
+   ASN1BOOL audioWithAL1M;
+   ASN1BOOL audioWithAL2M;
+   ASN1BOOL audioWithAL3M;
+   ASN1BOOL dataWithAL1M;
+   ASN1BOOL dataWithAL2M;
+   ASN1BOOL dataWithAL3M;
+   ASN1BOOL alpduInterleaving;
+   ASN1USINT maximumAL1MPDUSize;
+   ASN1USINT maximumAL2MSDUSize;
+   ASN1USINT maximumAL3MSDUSize;
+   ASN1BOOL rsCodeCapability;
+} H245H223AnnexCCapability;
+
+EXTERN int asn1PE_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue);
+
+EXTERN int asn1PD_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_mobileMultilinkFrameCapability             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223Capability_mobileMultilinkFrameCapability {
+   ASN1UINT8 maximumSampleSize;
+   ASN1USINT maximumPayloadLength;
+} H245H223Capability_mobileMultilinkFrameCapability;
+
+EXTERN int asn1PE_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue);
+
+EXTERN int asn1PD_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223Capability {
+   struct {
+      unsigned maxMUXPDUSizeCapabilityPresent : 1;
+      unsigned nsrpSupportPresent : 1;
+      unsigned mobileOperationTransmitCapabilityPresent : 1;
+      unsigned h223AnnexCCapabilityPresent : 1;
+      unsigned bitRatePresent : 1;
+      unsigned mobileMultilinkFrameCapabilityPresent : 1;
+   } m;
+   ASN1BOOL transportWithI_frames;
+   ASN1BOOL videoWithAL1;
+   ASN1BOOL videoWithAL2;
+   ASN1BOOL videoWithAL3;
+   ASN1BOOL audioWithAL1;
+   ASN1BOOL audioWithAL2;
+   ASN1BOOL audioWithAL3;
+   ASN1BOOL dataWithAL1;
+   ASN1BOOL dataWithAL2;
+   ASN1BOOL dataWithAL3;
+   ASN1USINT maximumAl2SDUSize;
+   ASN1USINT maximumAl3SDUSize;
+   ASN1USINT maximumDelayJitter;
+   H245H223Capability_h223MultiplexTableCapability h223MultiplexTableCapability;
+   ASN1BOOL maxMUXPDUSizeCapability;
+   ASN1BOOL nsrpSupport;
+   H245H223Capability_mobileOperationTransmitCapability mobileOperationTransmitCapability;
+   H245H223AnnexCCapability h223AnnexCCapability;
+   ASN1USINT bitRate;
+   H245H223Capability_mobileMultilinkFrameCapability mobileMultilinkFrameCapability;
+} H245H223Capability;
+
+EXTERN int asn1PE_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue);
+
+EXTERN int asn1PD_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V75Capability                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245V75Capability {
+   ASN1BOOL audioHeader;
+} H245V75Capability;
+
+EXTERN int asn1PE_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue);
+
+EXTERN int asn1PD_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V76Capability                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245V76Capability {
+   ASN1BOOL suspendResumeCapabilitywAddress;
+   ASN1BOOL suspendResumeCapabilitywoAddress;
+   ASN1BOOL rejCapability;
+   ASN1BOOL sREJCapability;
+   ASN1BOOL mREJCapability;
+   ASN1BOOL crc8bitCapability;
+   ASN1BOOL crc16bitCapability;
+   ASN1BOOL crc32bitCapability;
+   ASN1BOOL uihCapability;
+   ASN1USINT numOfDLCS;
+   ASN1BOOL twoOctetAddressFieldCapability;
+   ASN1BOOL loopBackTestCapability;
+   ASN1USINT n401Capability;
+   ASN1UINT8 maxWindowSizeCapability;
+   H245V75Capability v75Capability;
+} H245V76Capability;
+
+EXTERN int asn1PE_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue);
+
+EXTERN int asn1PD_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T84Profile_t84Restricted                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245T84Profile_t84Restricted {
+   ASN1BOOL qcif;
+   ASN1BOOL cif;
+   ASN1BOOL ccir601Seq;
+   ASN1BOOL ccir601Prog;
+   ASN1BOOL hdtvSeq;
+   ASN1BOOL hdtvProg;
+   ASN1BOOL g3FacsMH200x100;
+   ASN1BOOL g3FacsMH200x200;
+   ASN1BOOL g4FacsMMR200x100;
+   ASN1BOOL g4FacsMMR200x200;
+   ASN1BOOL jbig200x200Seq;
+   ASN1BOOL jbig200x200Prog;
+   ASN1BOOL jbig300x300Seq;
+   ASN1BOOL jbig300x300Prog;
+   ASN1BOOL digPhotoLow;
+   ASN1BOOL digPhotoMedSeq;
+   ASN1BOOL digPhotoMedProg;
+   ASN1BOOL digPhotoHighSeq;
+   ASN1BOOL digPhotoHighProg;
+} H245T84Profile_t84Restricted;
+
+EXTERN int asn1PE_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue);
+
+EXTERN int asn1PD_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  T84Profile                                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245T84Profile_t84Unrestricted 1
+#define T_H245T84Profile_t84Restricted  2
+
+typedef struct EXTERN H245T84Profile {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245T84Profile_t84Restricted *t84Restricted;
+   } u;
+} H245T84Profile;
+
+EXTERN int asn1PE_H245T84Profile (OOCTXT* pctxt, H245T84Profile* pvalue);
+
+EXTERN int asn1PD_H245T84Profile (OOCTXT* pctxt, H245T84Profile* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_t84                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245DataApplicationCapability_application_t84 {
+   H245DataProtocolCapability t84Protocol;
+   H245T84Profile t84Profile;
+} H245DataApplicationCapability_application_t84;
+
+EXTERN int asn1PE_H245DataApplicationCapability_application_t84 (OOCTXT* pctxt, H245DataApplicationCapability_application_t84* pvalue);
+
+EXTERN int asn1PD_H245DataApplicationCapability_application_t84 (OOCTXT* pctxt, H245DataApplicationCapability_application_t84* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_nlpid               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245DataApplicationCapability_application_nlpid {
+   H245DataProtocolCapability nlpidProtocol;
+   ASN1DynOctStr nlpidData;
+} H245DataApplicationCapability_application_nlpid;
+
+EXTERN int asn1PE_H245DataApplicationCapability_application_nlpid (OOCTXT* pctxt, H245DataApplicationCapability_application_nlpid* pvalue);
+
+EXTERN int asn1PD_H245DataApplicationCapability_application_nlpid (OOCTXT* pctxt, H245DataApplicationCapability_application_nlpid* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_t38fax              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245DataApplicationCapability_application_t38fax {
+   H245DataProtocolCapability t38FaxProtocol;
+   H245T38FaxProfile t38FaxProfile;
+} H245DataApplicationCapability_application_t38fax;
+
+EXTERN int asn1PE_H245DataApplicationCapability_application_t38fax (OOCTXT* pctxt, H245DataApplicationCapability_application_t38fax* pvalue);
+
+EXTERN int asn1PD_H245DataApplicationCapability_application_t38fax (OOCTXT* pctxt, H245DataApplicationCapability_application_t38fax* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityIdentifier_uuid                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CapabilityIdentifier_uuid {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H245CapabilityIdentifier_uuid;
+
+EXTERN int asn1PE_H245CapabilityIdentifier_uuid (OOCTXT* pctxt, H245CapabilityIdentifier_uuid* pvalue);
+
+EXTERN int asn1PD_H245CapabilityIdentifier_uuid (OOCTXT* pctxt, H245CapabilityIdentifier_uuid* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CapabilityIdentifier_standard 1
+#define T_H245CapabilityIdentifier_h221NonStandard 2
+#define T_H245CapabilityIdentifier_uuid 3
+#define T_H245CapabilityIdentifier_domainBased 4
+#define T_H245CapabilityIdentifier_extElem1 5
+
+typedef struct EXTERN H245CapabilityIdentifier {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1OBJID *standard;
+      /* t = 2 */
+      H245NonStandardParameter *h221NonStandard;
+      /* t = 3 */
+      H245CapabilityIdentifier_uuid *uuid;
+      /* t = 4 */
+      ASN1IA5String domainBased;
+      /* t = 5 */
+   } u;
+} H245CapabilityIdentifier;
+
+EXTERN int asn1PE_H245CapabilityIdentifier (OOCTXT* pctxt, H245CapabilityIdentifier* pvalue);
+
+EXTERN int asn1PD_H245CapabilityIdentifier (OOCTXT* pctxt, H245CapabilityIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterIdentifier_uuid                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ParameterIdentifier_uuid {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H245ParameterIdentifier_uuid;
+
+EXTERN int asn1PE_H245ParameterIdentifier_uuid (OOCTXT* pctxt, H245ParameterIdentifier_uuid* pvalue);
+
+EXTERN int asn1PD_H245ParameterIdentifier_uuid (OOCTXT* pctxt, H245ParameterIdentifier_uuid* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterIdentifier                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ParameterIdentifier_standard 1
+#define T_H245ParameterIdentifier_h221NonStandard 2
+#define T_H245ParameterIdentifier_uuid  3
+#define T_H245ParameterIdentifier_domainBased 4
+#define T_H245ParameterIdentifier_extElem1 5
+
+typedef struct EXTERN H245ParameterIdentifier {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1UINT8 standard;
+      /* t = 2 */
+      H245NonStandardParameter *h221NonStandard;
+      /* t = 3 */
+      H245ParameterIdentifier_uuid *uuid;
+      /* t = 4 */
+      ASN1IA5String domainBased;
+      /* t = 5 */
+   } u;
+} H245ParameterIdentifier;
+
+EXTERN int asn1PE_H245ParameterIdentifier (OOCTXT* pctxt, H245ParameterIdentifier* pvalue);
+
+EXTERN int asn1PD_H245ParameterIdentifier (OOCTXT* pctxt, H245ParameterIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterValue                                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ParameterValue_logical    1
+#define T_H245ParameterValue_booleanArray 2
+#define T_H245ParameterValue_unsignedMin 3
+#define T_H245ParameterValue_unsignedMax 4
+#define T_H245ParameterValue_unsigned32Min 5
+#define T_H245ParameterValue_unsigned32Max 6
+#define T_H245ParameterValue_octetString 7
+#define T_H245ParameterValue_genericParameter 8
+#define T_H245ParameterValue_extElem1   9
+
+typedef struct EXTERN H245ParameterValue {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      ASN1UINT8 booleanArray;
+      /* t = 3 */
+      ASN1USINT unsignedMin;
+      /* t = 4 */
+      ASN1USINT unsignedMax;
+      /* t = 5 */
+      ASN1UINT unsigned32Min;
+      /* t = 6 */
+      ASN1UINT unsigned32Max;
+      /* t = 7 */
+      ASN1DynOctStr *octetString;
+      /* t = 8 */
+      DList *genericParameter;
+      /* t = 9 */
+   } u;
+} H245ParameterValue;
+
+EXTERN int asn1PE_H245ParameterValue (OOCTXT* pctxt, H245ParameterValue* pvalue);
+
+EXTERN int asn1PD_H245ParameterValue (OOCTXT* pctxt, H245ParameterValue* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245ParameterIdentifier                             */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245ParameterIdentifier */
+typedef DList H245_SeqOfH245ParameterIdentifier;
+
+EXTERN int asn1PE_H245_SeqOfH245ParameterIdentifier (OOCTXT* pctxt, H245_SeqOfH245ParameterIdentifier* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245ParameterIdentifier (OOCTXT* pctxt, H245_SeqOfH245ParameterIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GenericParameter                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245GenericParameter {
+   struct {
+      unsigned supersedesPresent : 1;
+   } m;
+   H245ParameterIdentifier parameterIdentifier;
+   H245ParameterValue parameterValue;
+   H245_SeqOfH245ParameterIdentifier supersedes;
+} H245GenericParameter;
+
+EXTERN int asn1PE_H245GenericParameter (OOCTXT* pctxt, H245GenericParameter* pvalue);
+
+EXTERN int asn1PD_H245GenericParameter (OOCTXT* pctxt, H245GenericParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245GenericParameter                                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245GenericParameter */
+typedef DList H245_SeqOfH245GenericParameter;
+
+EXTERN int asn1PE_H245_SeqOfH245GenericParameter (OOCTXT* pctxt, H245_SeqOfH245GenericParameter* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245GenericParameter (OOCTXT* pctxt, H245_SeqOfH245GenericParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GenericCapability                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245GenericCapability {
+   struct {
+      unsigned maxBitRatePresent : 1;
+      unsigned collapsingPresent : 1;
+      unsigned nonCollapsingPresent : 1;
+      unsigned nonCollapsingRawPresent : 1;
+      unsigned transportPresent : 1;
+   } m;
+   H245CapabilityIdentifier capabilityIdentifier;
+   ASN1UINT maxBitRate;
+   H245_SeqOfH245GenericParameter collapsing;
+   H245_SeqOfH245GenericParameter nonCollapsing;
+   ASN1DynOctStr nonCollapsingRaw;
+   H245DataProtocolCapability transport;
+} H245GenericCapability;
+
+EXTERN int asn1PE_H245GenericCapability (OOCTXT* pctxt, H245GenericCapability* pvalue);
+
+EXTERN int asn1PD_H245GenericCapability (OOCTXT* pctxt, H245GenericCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245DataApplicationCapability_application_nonStandard 1
+#define T_H245DataApplicationCapability_application_t120 2
+#define T_H245DataApplicationCapability_application_dsm_cc 3
+#define T_H245DataApplicationCapability_application_userData 4
+#define T_H245DataApplicationCapability_application_t84 5
+#define T_H245DataApplicationCapability_application_t434 6
+#define T_H245DataApplicationCapability_application_h224 7
+#define T_H245DataApplicationCapability_application_nlpid 8
+#define T_H245DataApplicationCapability_application_dsvdControl 9
+#define T_H245DataApplicationCapability_application_h222DataPartitioning 10
+#define T_H245DataApplicationCapability_application_t30fax 11
+#define T_H245DataApplicationCapability_application_t140 12
+#define T_H245DataApplicationCapability_application_t38fax 13
+#define T_H245DataApplicationCapability_application_genericDataCapability 14
+#define T_H245DataApplicationCapability_application_extElem1 15
+
+typedef struct EXTERN H245DataApplicationCapability_application {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245DataProtocolCapability *t120;
+      /* t = 3 */
+      H245DataProtocolCapability *dsm_cc;
+      /* t = 4 */
+      H245DataProtocolCapability *userData;
+      /* t = 5 */
+      H245DataApplicationCapability_application_t84 *t84;
+      /* t = 6 */
+      H245DataProtocolCapability *t434;
+      /* t = 7 */
+      H245DataProtocolCapability *h224;
+      /* t = 8 */
+      H245DataApplicationCapability_application_nlpid *nlpid;
+      /* t = 9 */
+      /* t = 10 */
+      H245DataProtocolCapability *h222DataPartitioning;
+      /* t = 11 */
+      H245DataProtocolCapability *t30fax;
+      /* t = 12 */
+      H245DataProtocolCapability *t140;
+      /* t = 13 */
+      H245DataApplicationCapability_application_t38fax *t38fax;
+      /* t = 14 */
+      H245GenericCapability *genericDataCapability;
+      /* t = 15 */
+   } u;
+} H245DataApplicationCapability_application;
+
+EXTERN int asn1PE_H245DataApplicationCapability_application (OOCTXT* pctxt, H245DataApplicationCapability_application* pvalue);
+
+EXTERN int asn1PD_H245DataApplicationCapability_application (OOCTXT* pctxt, H245DataApplicationCapability_application* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245DataApplicationCapability {
+   H245DataApplicationCapability_application application;
+   ASN1UINT maxBitRate;
+} H245DataApplicationCapability;
+
+EXTERN int asn1PE_H245DataApplicationCapability (OOCTXT* pctxt, H245DataApplicationCapability* pvalue);
+
+EXTERN int asn1PD_H245DataApplicationCapability (OOCTXT* pctxt, H245DataApplicationCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245DataApplicationCapability                       */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245DataApplicationCapability */
+typedef DList H245_SeqOfH245DataApplicationCapability;
+
+EXTERN int asn1PE_H245_SeqOfH245DataApplicationCapability (OOCTXT* pctxt, H245_SeqOfH245DataApplicationCapability* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245DataApplicationCapability (OOCTXT* pctxt, H245_SeqOfH245DataApplicationCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MediaDistributionCapability                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MediaDistributionCapability {
+   struct {
+      unsigned centralizedDataPresent : 1;
+      unsigned distributedDataPresent : 1;
+   } m;
+   ASN1BOOL centralizedControl;
+   ASN1BOOL distributedControl;
+   ASN1BOOL centralizedAudio;
+   ASN1BOOL distributedAudio;
+   ASN1BOOL centralizedVideo;
+   ASN1BOOL distributedVideo;
+   H245_SeqOfH245DataApplicationCapability centralizedData;
+   H245_SeqOfH245DataApplicationCapability distributedData;
+} H245MediaDistributionCapability;
+
+EXTERN int asn1PE_H245MediaDistributionCapability (OOCTXT* pctxt, H245MediaDistributionCapability* pvalue);
+
+EXTERN int asn1PD_H245MediaDistributionCapability (OOCTXT* pctxt, H245MediaDistributionCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MediaDistributionCapability                     */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MediaDistributionCapability */
+typedef DList H245_SeqOfH245MediaDistributionCapability;
+
+EXTERN int asn1PE_H245_SeqOfH245MediaDistributionCapability (OOCTXT* pctxt, H245_SeqOfH245MediaDistributionCapability* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245MediaDistributionCapability (OOCTXT* pctxt, H245_SeqOfH245MediaDistributionCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultipointCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultipointCapability {
+   ASN1BOOL multicastCapability;
+   ASN1BOOL multiUniCastConference;
+   H245_SeqOfH245MediaDistributionCapability mediaDistributionCapability;
+} H245MultipointCapability;
+
+EXTERN int asn1PE_H245MultipointCapability (OOCTXT* pctxt, H245MultipointCapability* pvalue);
+
+EXTERN int asn1PD_H245MultipointCapability (OOCTXT* pctxt, H245MultipointCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability_mcCapability                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H2250Capability_mcCapability {
+   ASN1BOOL centralizedConferenceMC;
+   ASN1BOOL decentralizedConferenceMC;
+} H245H2250Capability_mcCapability;
+
+EXTERN int asn1PE_H245H2250Capability_mcCapability (OOCTXT* pctxt, H245H2250Capability_mcCapability* pvalue);
+
+EXTERN int asn1PD_H245H2250Capability_mcCapability (OOCTXT* pctxt, H245H2250Capability_mcCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPPayloadType_payloadDescriptor                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RTPPayloadType_payloadDescriptor_nonStandardIdentifier 1
+#define T_H245RTPPayloadType_payloadDescriptor_rfc_number 2
+#define T_H245RTPPayloadType_payloadDescriptor_oid 3
+#define T_H245RTPPayloadType_payloadDescriptor_extElem1 4
+
+typedef struct EXTERN H245RTPPayloadType_payloadDescriptor {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandardIdentifier;
+      /* t = 2 */
+      ASN1INT rfc_number;
+      /* t = 3 */
+      ASN1OBJID *oid;
+      /* t = 4 */
+   } u;
+} H245RTPPayloadType_payloadDescriptor;
+
+EXTERN int asn1PE_H245RTPPayloadType_payloadDescriptor (OOCTXT* pctxt, H245RTPPayloadType_payloadDescriptor* pvalue);
+
+EXTERN int asn1PD_H245RTPPayloadType_payloadDescriptor (OOCTXT* pctxt, H245RTPPayloadType_payloadDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPPayloadType                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RTPPayloadType {
+   struct {
+      unsigned payloadTypePresent : 1;
+   } m;
+   H245RTPPayloadType_payloadDescriptor payloadDescriptor;
+   ASN1UINT8 payloadType;
+} H245RTPPayloadType;
+
+EXTERN int asn1PE_H245RTPPayloadType (OOCTXT* pctxt, H245RTPPayloadType* pvalue);
+
+EXTERN int asn1PD_H245RTPPayloadType (OOCTXT* pctxt, H245RTPPayloadType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MediaPacketizationCapability_rtpPayloadType               */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245RTPPayloadType */
+typedef DList H245MediaPacketizationCapability_rtpPayloadType;
+
+EXTERN int asn1PE_H245MediaPacketizationCapability_rtpPayloadType (OOCTXT* pctxt, H245MediaPacketizationCapability_rtpPayloadType* pvalue);
+
+EXTERN int asn1PD_H245MediaPacketizationCapability_rtpPayloadType (OOCTXT* pctxt, H245MediaPacketizationCapability_rtpPayloadType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MediaPacketizationCapability                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MediaPacketizationCapability {
+   struct {
+      unsigned rtpPayloadTypePresent : 1;
+   } m;
+   ASN1BOOL h261aVideoPacketization;
+   H245MediaPacketizationCapability_rtpPayloadType rtpPayloadType;
+} H245MediaPacketizationCapability;
+
+EXTERN int asn1PE_H245MediaPacketizationCapability (OOCTXT* pctxt, H245MediaPacketizationCapability* pvalue);
+
+EXTERN int asn1PD_H245MediaPacketizationCapability (OOCTXT* pctxt, H245MediaPacketizationCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  QOSMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245QOSMode_guaranteedQOS     1
+#define T_H245QOSMode_controlledLoad    2
+#define T_H245QOSMode_extElem1          3
+
+typedef struct EXTERN H245QOSMode {
+   int t;
+} H245QOSMode;
+
+EXTERN int asn1PE_H245QOSMode (OOCTXT* pctxt, H245QOSMode* pvalue);
+
+EXTERN int asn1PD_H245QOSMode (OOCTXT* pctxt, H245QOSMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RSVPParameters                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RSVPParameters {
+   struct {
+      unsigned qosModePresent : 1;
+      unsigned tokenRatePresent : 1;
+      unsigned bucketSizePresent : 1;
+      unsigned peakRatePresent : 1;
+      unsigned minPolicedPresent : 1;
+      unsigned maxPktSizePresent : 1;
+   } m;
+   H245QOSMode qosMode;
+   ASN1UINT tokenRate;
+   ASN1UINT bucketSize;
+   ASN1UINT peakRate;
+   ASN1UINT minPoliced;
+   ASN1UINT maxPktSize;
+} H245RSVPParameters;
+
+EXTERN int asn1PE_H245RSVPParameters (OOCTXT* pctxt, H245RSVPParameters* pvalue);
+
+EXTERN int asn1PD_H245RSVPParameters (OOCTXT* pctxt, H245RSVPParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ATMParameters                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ATMParameters {
+   ASN1USINT maxNTUSize;
+   ASN1BOOL atmUBR;
+   ASN1BOOL atmrtVBR;
+   ASN1BOOL atmnrtVBR;
+   ASN1BOOL atmABR;
+   ASN1BOOL atmCBR;
+} H245ATMParameters;
+
+EXTERN int asn1PE_H245ATMParameters (OOCTXT* pctxt, H245ATMParameters* pvalue);
+
+EXTERN int asn1PD_H245ATMParameters (OOCTXT* pctxt, H245ATMParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  QOSCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245QOSCapability {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned rsvpParametersPresent : 1;
+      unsigned atmParametersPresent : 1;
+   } m;
+   H245NonStandardParameter nonStandardData;
+   H245RSVPParameters rsvpParameters;
+   H245ATMParameters atmParameters;
+} H245QOSCapability;
+
+EXTERN int asn1PE_H245QOSCapability (OOCTXT* pctxt, H245QOSCapability* pvalue);
+
+EXTERN int asn1PD_H245QOSCapability (OOCTXT* pctxt, H245QOSCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability_qOSCapabilities                       */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245QOSCapability */
+typedef DList H245TransportCapability_qOSCapabilities;
+
+EXTERN int asn1PE_H245TransportCapability_qOSCapabilities (OOCTXT* pctxt, H245TransportCapability_qOSCapabilities* pvalue);
+
+EXTERN int asn1PD_H245TransportCapability_qOSCapabilities (OOCTXT* pctxt, H245TransportCapability_qOSCapabilities* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MediaTransportType_atm_AAL5_compressed                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MediaTransportType_atm_AAL5_compressed {
+   ASN1BOOL variable_delta;
+} H245MediaTransportType_atm_AAL5_compressed;
+
+EXTERN int asn1PE_H245MediaTransportType_atm_AAL5_compressed (OOCTXT* pctxt, H245MediaTransportType_atm_AAL5_compressed* pvalue);
+
+EXTERN int asn1PD_H245MediaTransportType_atm_AAL5_compressed (OOCTXT* pctxt, H245MediaTransportType_atm_AAL5_compressed* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MediaTransportType                                        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MediaTransportType_ip_UDP 1
+#define T_H245MediaTransportType_ip_TCP 2
+#define T_H245MediaTransportType_atm_AAL5_UNIDIR 3
+#define T_H245MediaTransportType_atm_AAL5_BIDIR 4
+#define T_H245MediaTransportType_atm_AAL5_compressed 5
+#define T_H245MediaTransportType_extElem1 6
+
+typedef struct EXTERN H245MediaTransportType {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      H245MediaTransportType_atm_AAL5_compressed *atm_AAL5_compressed;
+      /* t = 6 */
+   } u;
+} H245MediaTransportType;
+
+EXTERN int asn1PE_H245MediaTransportType (OOCTXT* pctxt, H245MediaTransportType* pvalue);
+
+EXTERN int asn1PD_H245MediaTransportType (OOCTXT* pctxt, H245MediaTransportType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MediaChannelCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MediaChannelCapability {
+   struct {
+      unsigned mediaTransportPresent : 1;
+   } m;
+   H245MediaTransportType mediaTransport;
+} H245MediaChannelCapability;
+
+EXTERN int asn1PE_H245MediaChannelCapability (OOCTXT* pctxt, H245MediaChannelCapability* pvalue);
+
+EXTERN int asn1PD_H245MediaChannelCapability (OOCTXT* pctxt, H245MediaChannelCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability_mediaChannelCapabilities              */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MediaChannelCapability */
+typedef DList H245TransportCapability_mediaChannelCapabilities;
+
+EXTERN int asn1PE_H245TransportCapability_mediaChannelCapabilities (OOCTXT* pctxt, H245TransportCapability_mediaChannelCapabilities* pvalue);
+
+EXTERN int asn1PD_H245TransportCapability_mediaChannelCapabilities (OOCTXT* pctxt, H245TransportCapability_mediaChannelCapabilities* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TransportCapability {
+   struct {
+      unsigned nonStandardPresent : 1;
+      unsigned qOSCapabilitiesPresent : 1;
+      unsigned mediaChannelCapabilitiesPresent : 1;
+   } m;
+   H245NonStandardParameter nonStandard;
+   H245TransportCapability_qOSCapabilities qOSCapabilities;
+   H245TransportCapability_mediaChannelCapabilities mediaChannelCapabilities;
+} H245TransportCapability;
+
+EXTERN int asn1PE_H245TransportCapability (OOCTXT* pctxt, H245TransportCapability* pvalue);
+
+EXTERN int asn1PD_H245TransportCapability (OOCTXT* pctxt, H245TransportCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyFrameMapping_frameSequence          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RTPH263VideoRedundancyFrameMapping_frameSequence {
+   ASN1UINT n;
+   ASN1UINT8 elem[256];
+} H245RTPH263VideoRedundancyFrameMapping_frameSequence;
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyFrameMapping_frameSequence (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping_frameSequence* pvalue);
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyFrameMapping_frameSequence (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping_frameSequence* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyFrameMapping                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RTPH263VideoRedundancyFrameMapping {
+   ASN1UINT8 threadNumber;
+   H245RTPH263VideoRedundancyFrameMapping_frameSequence frameSequence;
+} H245RTPH263VideoRedundancyFrameMapping;
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyFrameMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping* pvalue);
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyFrameMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_frameToThreadMapping_cust  */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245RTPH263VideoRedundancyFrameMapping */
+typedef DList H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom;
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom* pvalue);
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_frameToThreadMapping       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_roundrobin 1
+#define T_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom 2
+#define T_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_extElem1 3
+
+typedef struct EXTERN H245RTPH263VideoRedundancyEncoding_frameToThreadMapping {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom *custom;
+      /* t = 3 */
+   } u;
+} H245RTPH263VideoRedundancyEncoding_frameToThreadMapping;
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping* pvalue);
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_containedThreads           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RTPH263VideoRedundancyEncoding_containedThreads {
+   ASN1UINT n;
+   ASN1UINT8 elem[256];
+} H245RTPH263VideoRedundancyEncoding_containedThreads;
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_containedThreads (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_containedThreads* pvalue);
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_containedThreads (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_containedThreads* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RTPH263VideoRedundancyEncoding {
+   struct {
+      unsigned containedThreadsPresent : 1;
+   } m;
+   ASN1UINT8 numberOfThreads;
+   ASN1USINT framesBetweenSyncPoints;
+   H245RTPH263VideoRedundancyEncoding_frameToThreadMapping frameToThreadMapping;
+   H245RTPH263VideoRedundancyEncoding_containedThreads containedThreads;
+} H245RTPH263VideoRedundancyEncoding;
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding* pvalue);
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMethod                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RedundancyEncodingMethod_nonStandard 1
+#define T_H245RedundancyEncodingMethod_rtpAudioRedundancyEncoding 2
+#define T_H245RedundancyEncodingMethod_rtpH263VideoRedundancyEncoding 3
+#define T_H245RedundancyEncodingMethod_extElem1 4
+
+typedef struct EXTERN H245RedundancyEncodingMethod {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      H245RTPH263VideoRedundancyEncoding *rtpH263VideoRedundancyEncoding;
+      /* t = 4 */
+   } u;
+} H245RedundancyEncodingMethod;
+
+EXTERN int asn1PE_H245RedundancyEncodingMethod (OOCTXT* pctxt, H245RedundancyEncodingMethod* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingMethod (OOCTXT* pctxt, H245RedundancyEncodingMethod* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityTableEntryNumber                                */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1USINT H245CapabilityTableEntryNumber;
+
+EXTERN int asn1PE_H245CapabilityTableEntryNumber (OOCTXT* pctxt, H245CapabilityTableEntryNumber value);
+
+EXTERN int asn1PD_H245CapabilityTableEntryNumber (OOCTXT* pctxt, H245CapabilityTableEntryNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingCapability_secondaryEncoding            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RedundancyEncodingCapability_secondaryEncoding {
+   ASN1UINT n;
+   H245CapabilityTableEntryNumber elem[256];
+} H245RedundancyEncodingCapability_secondaryEncoding;
+
+EXTERN int asn1PE_H245RedundancyEncodingCapability_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingCapability_secondaryEncoding* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingCapability_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingCapability_secondaryEncoding* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingCapability                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RedundancyEncodingCapability {
+   struct {
+      unsigned secondaryEncodingPresent : 1;
+   } m;
+   H245RedundancyEncodingMethod redundancyEncodingMethod;
+   H245CapabilityTableEntryNumber primaryEncoding;
+   H245RedundancyEncodingCapability_secondaryEncoding secondaryEncoding;
+} H245RedundancyEncodingCapability;
+
+EXTERN int asn1PE_H245RedundancyEncodingCapability (OOCTXT* pctxt, H245RedundancyEncodingCapability* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingCapability (OOCTXT* pctxt, H245RedundancyEncodingCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability_redundancyEncodingCapability              */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245RedundancyEncodingCapability */
+typedef DList H245H2250Capability_redundancyEncodingCapability;
+
+EXTERN int asn1PE_H245H2250Capability_redundancyEncodingCapability (OOCTXT* pctxt, H245H2250Capability_redundancyEncodingCapability* pvalue);
+
+EXTERN int asn1PD_H245H2250Capability_redundancyEncodingCapability (OOCTXT* pctxt, H245H2250Capability_redundancyEncodingCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H2250Capability {
+   struct {
+      unsigned transportCapabilityPresent : 1;
+      unsigned redundancyEncodingCapabilityPresent : 1;
+      unsigned logicalChannelSwitchingCapabilityPresent : 1;
+      unsigned t120DynamicPortCapabilityPresent : 1;
+   } m;
+   ASN1USINT maximumAudioDelayJitter;
+   H245MultipointCapability receiveMultipointCapability;
+   H245MultipointCapability transmitMultipointCapability;
+   H245MultipointCapability receiveAndTransmitMultipointCapability;
+   H245H2250Capability_mcCapability mcCapability;
+   ASN1BOOL rtcpVideoControlCapability;
+   H245MediaPacketizationCapability mediaPacketizationCapability;
+   H245TransportCapability transportCapability;
+   H245H2250Capability_redundancyEncodingCapability redundancyEncodingCapability;
+   ASN1BOOL logicalChannelSwitchingCapability;
+   ASN1BOOL t120DynamicPortCapability;
+} H245H2250Capability;
+
+EXTERN int asn1PE_H245H2250Capability (OOCTXT* pctxt, H245H2250Capability* pvalue);
+
+EXTERN int asn1PD_H245H2250Capability (OOCTXT* pctxt, H245H2250Capability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultiplexCapability_nonStandard 1
+#define T_H245MultiplexCapability_h222Capability 2
+#define T_H245MultiplexCapability_h223Capability 3
+#define T_H245MultiplexCapability_v76Capability 4
+#define T_H245MultiplexCapability_h2250Capability 5
+#define T_H245MultiplexCapability_genericMultiplexCapability 6
+#define T_H245MultiplexCapability_extElem1 7
+
+typedef struct EXTERN H245MultiplexCapability {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245H222Capability *h222Capability;
+      /* t = 3 */
+      H245H223Capability *h223Capability;
+      /* t = 4 */
+      H245V76Capability *v76Capability;
+      /* t = 5 */
+      H245H2250Capability *h2250Capability;
+      /* t = 6 */
+      H245GenericCapability *genericMultiplexCapability;
+      /* t = 7 */
+   } u;
+} H245MultiplexCapability;
+
+EXTERN int asn1PE_H245MultiplexCapability (OOCTXT* pctxt, H245MultiplexCapability* pvalue);
+
+EXTERN int asn1PD_H245MultiplexCapability (OOCTXT* pctxt, H245MultiplexCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H261VideoCapability {
+   struct {
+      unsigned qcifMPIPresent : 1;
+      unsigned cifMPIPresent : 1;
+      unsigned videoBadMBsCapPresent : 1;
+   } m;
+   ASN1UINT8 qcifMPI;
+   ASN1UINT8 cifMPI;
+   ASN1BOOL temporalSpatialTradeOffCapability;
+   ASN1USINT maxBitRate;
+   ASN1BOOL stillImageTransmission;
+   ASN1BOOL videoBadMBsCap;
+} H245H261VideoCapability;
+
+EXTERN int asn1PE_H245H261VideoCapability (OOCTXT* pctxt, H245H261VideoCapability* pvalue);
+
+EXTERN int asn1PD_H245H261VideoCapability (OOCTXT* pctxt, H245H261VideoCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H262VideoCapability {
+   struct {
+      unsigned videoBitRatePresent : 1;
+      unsigned vbvBufferSizePresent : 1;
+      unsigned samplesPerLinePresent : 1;
+      unsigned linesPerFramePresent : 1;
+      unsigned framesPerSecondPresent : 1;
+      unsigned luminanceSampleRatePresent : 1;
+      unsigned videoBadMBsCapPresent : 1;
+   } m;
+   ASN1BOOL profileAndLevel_SPatML;
+   ASN1BOOL profileAndLevel_MPatLL;
+   ASN1BOOL profileAndLevel_MPatML;
+   ASN1BOOL profileAndLevel_MPatH_14;
+   ASN1BOOL profileAndLevel_MPatHL;
+   ASN1BOOL profileAndLevel_SNRatLL;
+   ASN1BOOL profileAndLevel_SNRatML;
+   ASN1BOOL profileAndLevel_SpatialatH_14;
+   ASN1BOOL profileAndLevel_HPatML;
+   ASN1BOOL profileAndLevel_HPatH_14;
+   ASN1BOOL profileAndLevel_HPatHL;
+   ASN1UINT videoBitRate;
+   ASN1UINT vbvBufferSize;
+   ASN1USINT samplesPerLine;
+   ASN1USINT linesPerFrame;
+   ASN1UINT8 framesPerSecond;
+   ASN1UINT luminanceSampleRate;
+   ASN1BOOL videoBadMBsCap;
+} H245H262VideoCapability;
+
+EXTERN int asn1PE_H245H262VideoCapability (OOCTXT* pctxt, H245H262VideoCapability* pvalue);
+
+EXTERN int asn1PD_H245H262VideoCapability (OOCTXT* pctxt, H245H262VideoCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransparencyParameters                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TransparencyParameters {
+   ASN1USINT presentationOrder;
+   ASN1INT offset_x;
+   ASN1INT offset_y;
+   ASN1UINT8 scale_x;
+   ASN1UINT8 scale_y;
+} H245TransparencyParameters;
+
+EXTERN int asn1PE_H245TransparencyParameters (OOCTXT* pctxt, H245TransparencyParameters* pvalue);
+
+EXTERN int asn1PD_H245TransparencyParameters (OOCTXT* pctxt, H245TransparencyParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_additionalPictureMemory               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RefPictureSelection_additionalPictureMemory {
+   struct {
+      unsigned sqcifAdditionalPictureMemoryPresent : 1;
+      unsigned qcifAdditionalPictureMemoryPresent : 1;
+      unsigned cifAdditionalPictureMemoryPresent : 1;
+      unsigned cif4AdditionalPictureMemoryPresent : 1;
+      unsigned cif16AdditionalPictureMemoryPresent : 1;
+      unsigned bigCpfAdditionalPictureMemoryPresent : 1;
+   } m;
+   ASN1USINT sqcifAdditionalPictureMemory;
+   ASN1USINT qcifAdditionalPictureMemory;
+   ASN1USINT cifAdditionalPictureMemory;
+   ASN1USINT cif4AdditionalPictureMemory;
+   ASN1USINT cif16AdditionalPictureMemory;
+   ASN1USINT bigCpfAdditionalPictureMemory;
+} H245RefPictureSelection_additionalPictureMemory;
+
+EXTERN int asn1PE_H245RefPictureSelection_additionalPictureMemory (OOCTXT* pctxt, H245RefPictureSelection_additionalPictureMemory* pvalue);
+
+EXTERN int asn1PD_H245RefPictureSelection_additionalPictureMemory (OOCTXT* pctxt, H245RefPictureSelection_additionalPictureMemory* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_videoBackChannelSend                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RefPictureSelection_videoBackChannelSend_none 1
+#define T_H245RefPictureSelection_videoBackChannelSend_ackMessageOnly 2
+#define T_H245RefPictureSelection_videoBackChannelSend_nackMessageOnly 3
+#define T_H245RefPictureSelection_videoBackChannelSend_ackOrNackMessageOnly 4
+#define T_H245RefPictureSelection_videoBackChannelSend_ackAndNackMessage 5
+#define T_H245RefPictureSelection_videoBackChannelSend_extElem1 6
+
+typedef struct EXTERN H245RefPictureSelection_videoBackChannelSend {
+   int t;
+} H245RefPictureSelection_videoBackChannelSend;
+
+EXTERN int asn1PE_H245RefPictureSelection_videoBackChannelSend (OOCTXT* pctxt, H245RefPictureSelection_videoBackChannelSend* pvalue);
+
+EXTERN int asn1PD_H245RefPictureSelection_videoBackChannelSend (OOCTXT* pctxt, H245RefPictureSelection_videoBackChannelSend* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_enhancedReferencePicSelect_subPictur  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters {
+   ASN1UINT8 mpuHorizMBs;
+   ASN1UINT8 mpuVertMBs;
+   ASN1UINT mpuTotalNumber;
+} H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters;
+
+EXTERN int asn1PE_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters* pvalue);
+
+EXTERN int asn1PD_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_enhancedReferencePicSelect            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RefPictureSelection_enhancedReferencePicSelect {
+   struct {
+      unsigned subPictureRemovalParametersPresent : 1;
+   } m;
+   H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters subPictureRemovalParameters;
+} H245RefPictureSelection_enhancedReferencePicSelect;
+
+EXTERN int asn1PE_H245RefPictureSelection_enhancedReferencePicSelect (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect* pvalue);
+
+EXTERN int asn1PD_H245RefPictureSelection_enhancedReferencePicSelect (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RefPictureSelection {
+   struct {
+      unsigned additionalPictureMemoryPresent : 1;
+      unsigned enhancedReferencePicSelectPresent : 1;
+   } m;
+   H245RefPictureSelection_additionalPictureMemory additionalPictureMemory;
+   ASN1BOOL videoMux;
+   H245RefPictureSelection_videoBackChannelSend videoBackChannelSend;
+   H245RefPictureSelection_enhancedReferencePicSelect enhancedReferencePicSelect;
+} H245RefPictureSelection;
+
+EXTERN int asn1PE_H245RefPictureSelection (OOCTXT* pctxt, H245RefPictureSelection* pvalue);
+
+EXTERN int asn1PD_H245RefPictureSelection (OOCTXT* pctxt, H245RefPictureSelection* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureClockFrequency                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CustomPictureClockFrequency {
+   struct {
+      unsigned sqcifMPIPresent : 1;
+      unsigned qcifMPIPresent : 1;
+      unsigned cifMPIPresent : 1;
+      unsigned cif4MPIPresent : 1;
+      unsigned cif16MPIPresent : 1;
+   } m;
+   ASN1USINT clockConversionCode;
+   ASN1UINT8 clockDivisor;
+   ASN1USINT sqcifMPI;
+   ASN1USINT qcifMPI;
+   ASN1USINT cifMPI;
+   ASN1USINT cif4MPI;
+   ASN1USINT cif16MPI;
+} H245CustomPictureClockFrequency;
+
+EXTERN int asn1PE_H245CustomPictureClockFrequency (OOCTXT* pctxt, H245CustomPictureClockFrequency* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureClockFrequency (OOCTXT* pctxt, H245CustomPictureClockFrequency* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_customPictureClockFrequency                   */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245CustomPictureClockFrequency */
+typedef DList H245H263Options_customPictureClockFrequency;
+
+EXTERN int asn1PE_H245H263Options_customPictureClockFrequency (OOCTXT* pctxt, H245H263Options_customPictureClockFrequency* pvalue);
+
+EXTERN int asn1PD_H245H263Options_customPictureClockFrequency (OOCTXT* pctxt, H245H263Options_customPictureClockFrequency* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI_customPCF_element                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CustomPictureFormat_mPI_customPCF_element {
+   ASN1USINT clockConversionCode;
+   ASN1UINT8 clockDivisor;
+   ASN1USINT customMPI;
+} H245CustomPictureFormat_mPI_customPCF_element;
+
+EXTERN int asn1PE_H245CustomPictureFormat_mPI_customPCF_element (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF_element* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureFormat_mPI_customPCF_element (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI_customPCF                         */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245CustomPictureFormat_mPI_customPCF_element */
+typedef DList H245CustomPictureFormat_mPI_customPCF;
+
+EXTERN int asn1PE_H245CustomPictureFormat_mPI_customPCF (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureFormat_mPI_customPCF (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CustomPictureFormat_mPI {
+   struct {
+      unsigned standardMPIPresent : 1;
+      unsigned customPCFPresent : 1;
+   } m;
+   ASN1UINT8 standardMPI;
+   H245CustomPictureFormat_mPI_customPCF customPCF;
+} H245CustomPictureFormat_mPI;
+
+EXTERN int asn1PE_H245CustomPictureFormat_mPI (OOCTXT* pctxt, H245CustomPictureFormat_mPI* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureFormat_mPI (OOCTXT* pctxt, H245CustomPictureFormat_mPI* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_pixelAspectCo  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode {
+   ASN1UINT n;
+   ASN1UINT8 elem[14];
+} H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode;
+
+EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_extendedPAR_e  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element {
+   ASN1UINT8 width;
+   ASN1UINT8 height;
+} H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element;
+
+EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_extendedPAR    */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element */
+typedef DList H245CustomPictureFormat_pixelAspectInformation_extendedPAR;
+
+EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CustomPictureFormat_pixelAspectInformation_anyPixelAspectRatio 1
+#define T_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode 2
+#define T_H245CustomPictureFormat_pixelAspectInformation_extendedPAR 3
+#define T_H245CustomPictureFormat_pixelAspectInformation_extElem1 4
+
+typedef struct EXTERN H245CustomPictureFormat_pixelAspectInformation {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1BOOL anyPixelAspectRatio;
+      /* t = 2 */
+      H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode *pixelAspectCode;
+      /* t = 3 */
+      H245CustomPictureFormat_pixelAspectInformation_extendedPAR *extendedPAR;
+      /* t = 4 */
+   } u;
+} H245CustomPictureFormat_pixelAspectInformation;
+
+EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CustomPictureFormat {
+   ASN1USINT maxCustomPictureWidth;
+   ASN1USINT maxCustomPictureHeight;
+   ASN1USINT minCustomPictureWidth;
+   ASN1USINT minCustomPictureHeight;
+   H245CustomPictureFormat_mPI mPI;
+   H245CustomPictureFormat_pixelAspectInformation pixelAspectInformation;
+} H245CustomPictureFormat;
+
+EXTERN int asn1PE_H245CustomPictureFormat (OOCTXT* pctxt, H245CustomPictureFormat* pvalue);
+
+EXTERN int asn1PD_H245CustomPictureFormat (OOCTXT* pctxt, H245CustomPictureFormat* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_customPictureFormat                           */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245CustomPictureFormat */
+typedef DList H245H263Options_customPictureFormat;
+
+EXTERN int asn1PE_H245H263Options_customPictureFormat (OOCTXT* pctxt, H245H263Options_customPictureFormat* pvalue);
+
+EXTERN int asn1PD_H245H263Options_customPictureFormat (OOCTXT* pctxt, H245H263Options_customPictureFormat* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263Version3Options                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H263Version3Options {
+   ASN1BOOL dataPartitionedSlices;
+   ASN1BOOL fixedPointIDCT0;
+   ASN1BOOL interlacedFields;
+   ASN1BOOL currentPictureHeaderRepetition;
+   ASN1BOOL previousPictureHeaderRepetition;
+   ASN1BOOL nextPictureHeaderRepetition;
+   ASN1BOOL pictureNumber;
+   ASN1BOOL spareReferencePictures;
+} H245H263Version3Options;
+
+EXTERN int asn1PE_H245H263Version3Options (OOCTXT* pctxt, H245H263Version3Options* pvalue);
+
+EXTERN int asn1PD_H245H263Version3Options (OOCTXT* pctxt, H245H263Version3Options* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263ModeComboFlags                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H263ModeComboFlags {
+   struct {
+      unsigned enhancedReferencePicSelectPresent : 1;
+      unsigned h263Version3OptionsPresent : 1;
+   } m;
+   ASN1BOOL unrestrictedVector;
+   ASN1BOOL arithmeticCoding;
+   ASN1BOOL advancedPrediction;
+   ASN1BOOL pbFrames;
+   ASN1BOOL advancedIntraCodingMode;
+   ASN1BOOL deblockingFilterMode;
+   ASN1BOOL unlimitedMotionVectors;
+   ASN1BOOL slicesInOrder_NonRect;
+   ASN1BOOL slicesInOrder_Rect;
+   ASN1BOOL slicesNoOrder_NonRect;
+   ASN1BOOL slicesNoOrder_Rect;
+   ASN1BOOL improvedPBFramesMode;
+   ASN1BOOL referencePicSelect;
+   ASN1BOOL dynamicPictureResizingByFour;
+   ASN1BOOL dynamicPictureResizingSixteenthPel;
+   ASN1BOOL dynamicWarpingHalfPel;
+   ASN1BOOL dynamicWarpingSixteenthPel;
+   ASN1BOOL reducedResolutionUpdate;
+   ASN1BOOL independentSegmentDecoding;
+   ASN1BOOL alternateInterVLCMode;
+   ASN1BOOL modifiedQuantizationMode;
+   ASN1BOOL enhancedReferencePicSelect;
+   H245H263Version3Options h263Version3Options;
+} H245H263ModeComboFlags;
+
+EXTERN int asn1PE_H245H263ModeComboFlags (OOCTXT* pctxt, H245H263ModeComboFlags* pvalue);
+
+EXTERN int asn1PD_H245H263ModeComboFlags (OOCTXT* pctxt, H245H263ModeComboFlags* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoModeCombos_h263VideoCoupledModes                 */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245H263ModeComboFlags */
+typedef DList H245H263VideoModeCombos_h263VideoCoupledModes;
+
+EXTERN int asn1PE_H245H263VideoModeCombos_h263VideoCoupledModes (OOCTXT* pctxt, H245H263VideoModeCombos_h263VideoCoupledModes* pvalue);
+
+EXTERN int asn1PD_H245H263VideoModeCombos_h263VideoCoupledModes (OOCTXT* pctxt, H245H263VideoModeCombos_h263VideoCoupledModes* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoModeCombos                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H263VideoModeCombos {
+   H245H263ModeComboFlags h263VideoUncoupledModes;
+   H245H263VideoModeCombos_h263VideoCoupledModes h263VideoCoupledModes;
+} H245H263VideoModeCombos;
+
+EXTERN int asn1PE_H245H263VideoModeCombos (OOCTXT* pctxt, H245H263VideoModeCombos* pvalue);
+
+EXTERN int asn1PD_H245H263VideoModeCombos (OOCTXT* pctxt, H245H263VideoModeCombos* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_modeCombos                                    */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245H263VideoModeCombos */
+typedef DList H245H263Options_modeCombos;
+
+EXTERN int asn1PE_H245H263Options_modeCombos (OOCTXT* pctxt, H245H263Options_modeCombos* pvalue);
+
+EXTERN int asn1PD_H245H263Options_modeCombos (OOCTXT* pctxt, H245H263Options_modeCombos* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H263Options {
+   struct {
+      unsigned transparencyParametersPresent : 1;
+      unsigned refPictureSelectionPresent : 1;
+      unsigned customPictureClockFrequencyPresent : 1;
+      unsigned customPictureFormatPresent : 1;
+      unsigned modeCombosPresent : 1;
+      unsigned videoBadMBsCapPresent : 1;
+      unsigned h263Version3OptionsPresent : 1;
+   } m;
+   ASN1BOOL advancedIntraCodingMode;
+   ASN1BOOL deblockingFilterMode;
+   ASN1BOOL improvedPBFramesMode;
+   ASN1BOOL unlimitedMotionVectors;
+   ASN1BOOL fullPictureFreeze;
+   ASN1BOOL partialPictureFreezeAndRelease;
+   ASN1BOOL resizingPartPicFreezeAndRelease;
+   ASN1BOOL fullPictureSnapshot;
+   ASN1BOOL partialPictureSnapshot;
+   ASN1BOOL videoSegmentTagging;
+   ASN1BOOL progressiveRefinement;
+   ASN1BOOL dynamicPictureResizingByFour;
+   ASN1BOOL dynamicPictureResizingSixteenthPel;
+   ASN1BOOL dynamicWarpingHalfPel;
+   ASN1BOOL dynamicWarpingSixteenthPel;
+   ASN1BOOL independentSegmentDecoding;
+   ASN1BOOL slicesInOrder_NonRect;
+   ASN1BOOL slicesInOrder_Rect;
+   ASN1BOOL slicesNoOrder_NonRect;
+   ASN1BOOL slicesNoOrder_Rect;
+   ASN1BOOL alternateInterVLCMode;
+   ASN1BOOL modifiedQuantizationMode;
+   ASN1BOOL reducedResolutionUpdate;
+   H245TransparencyParameters transparencyParameters;
+   ASN1BOOL separateVideoBackChannel;
+   H245RefPictureSelection refPictureSelection;
+   H245H263Options_customPictureClockFrequency customPictureClockFrequency;
+   H245H263Options_customPictureFormat customPictureFormat;
+   H245H263Options_modeCombos modeCombos;
+   ASN1BOOL videoBadMBsCap;
+   H245H263Version3Options h263Version3Options;
+} H245H263Options;
+
+EXTERN int asn1PE_H245H263Options (OOCTXT* pctxt, H245H263Options* pvalue);
+
+EXTERN int asn1PD_H245H263Options (OOCTXT* pctxt, H245H263Options* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementOptions                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245EnhancementOptions {
+   struct {
+      unsigned sqcifMPIPresent : 1;
+      unsigned qcifMPIPresent : 1;
+      unsigned cifMPIPresent : 1;
+      unsigned cif4MPIPresent : 1;
+      unsigned cif16MPIPresent : 1;
+      unsigned slowSqcifMPIPresent : 1;
+      unsigned slowQcifMPIPresent : 1;
+      unsigned slowCifMPIPresent : 1;
+      unsigned slowCif4MPIPresent : 1;
+      unsigned slowCif16MPIPresent : 1;
+      unsigned h263OptionsPresent : 1;
+   } m;
+   ASN1UINT8 sqcifMPI;
+   ASN1UINT8 qcifMPI;
+   ASN1UINT8 cifMPI;
+   ASN1UINT8 cif4MPI;
+   ASN1UINT8 cif16MPI;
+   ASN1UINT maxBitRate;
+   ASN1BOOL unrestrictedVector;
+   ASN1BOOL arithmeticCoding;
+   ASN1BOOL temporalSpatialTradeOffCapability;
+   ASN1USINT slowSqcifMPI;
+   ASN1USINT slowQcifMPI;
+   ASN1USINT slowCifMPI;
+   ASN1USINT slowCif4MPI;
+   ASN1USINT slowCif16MPI;
+   ASN1BOOL errorCompensation;
+   H245H263Options h263Options;
+} H245EnhancementOptions;
+
+EXTERN int asn1PE_H245EnhancementOptions (OOCTXT* pctxt, H245EnhancementOptions* pvalue);
+
+EXTERN int asn1PD_H245EnhancementOptions (OOCTXT* pctxt, H245EnhancementOptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_snrEnhancement                       */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245EnhancementOptions */
+typedef DList H245EnhancementLayerInfo_snrEnhancement;
+
+EXTERN int asn1PE_H245EnhancementLayerInfo_snrEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_snrEnhancement* pvalue);
+
+EXTERN int asn1PD_H245EnhancementLayerInfo_snrEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_snrEnhancement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_spatialEnhancement                   */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245EnhancementOptions */
+typedef DList H245EnhancementLayerInfo_spatialEnhancement;
+
+EXTERN int asn1PE_H245EnhancementLayerInfo_spatialEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_spatialEnhancement* pvalue);
+
+EXTERN int asn1PD_H245EnhancementLayerInfo_spatialEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_spatialEnhancement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  BEnhancementParameters                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245BEnhancementParameters {
+   H245EnhancementOptions enhancementOptions;
+   ASN1UINT8 numberOfBPictures;
+} H245BEnhancementParameters;
+
+EXTERN int asn1PE_H245BEnhancementParameters (OOCTXT* pctxt, H245BEnhancementParameters* pvalue);
+
+EXTERN int asn1PD_H245BEnhancementParameters (OOCTXT* pctxt, H245BEnhancementParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_bPictureEnhancement                  */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245BEnhancementParameters */
+typedef DList H245EnhancementLayerInfo_bPictureEnhancement;
+
+EXTERN int asn1PE_H245EnhancementLayerInfo_bPictureEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_bPictureEnhancement* pvalue);
+
+EXTERN int asn1PD_H245EnhancementLayerInfo_bPictureEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_bPictureEnhancement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245EnhancementLayerInfo {
+   struct {
+      unsigned snrEnhancementPresent : 1;
+      unsigned spatialEnhancementPresent : 1;
+      unsigned bPictureEnhancementPresent : 1;
+   } m;
+   ASN1BOOL baseBitRateConstrained;
+   H245EnhancementLayerInfo_snrEnhancement snrEnhancement;
+   H245EnhancementLayerInfo_spatialEnhancement spatialEnhancement;
+   H245EnhancementLayerInfo_bPictureEnhancement bPictureEnhancement;
+} H245EnhancementLayerInfo;
+
+EXTERN int asn1PE_H245EnhancementLayerInfo (OOCTXT* pctxt, H245EnhancementLayerInfo* pvalue);
+
+EXTERN int asn1PD_H245EnhancementLayerInfo (OOCTXT* pctxt, H245EnhancementLayerInfo* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H263VideoCapability {
+   struct {
+      unsigned sqcifMPIPresent : 1;
+      unsigned qcifMPIPresent : 1;
+      unsigned cifMPIPresent : 1;
+      unsigned cif4MPIPresent : 1;
+      unsigned cif16MPIPresent : 1;
+      unsigned hrd_BPresent : 1;
+      unsigned bppMaxKbPresent : 1;
+      unsigned slowSqcifMPIPresent : 1;
+      unsigned slowQcifMPIPresent : 1;
+      unsigned slowCifMPIPresent : 1;
+      unsigned slowCif4MPIPresent : 1;
+      unsigned slowCif16MPIPresent : 1;
+      unsigned errorCompensationPresent : 1;
+      unsigned enhancementLayerInfoPresent : 1;
+      unsigned h263OptionsPresent : 1;
+   } m;
+   ASN1UINT8 sqcifMPI;
+   ASN1UINT8 qcifMPI;
+   ASN1UINT8 cifMPI;
+   ASN1UINT8 cif4MPI;
+   ASN1UINT8 cif16MPI;
+   ASN1UINT maxBitRate;
+   ASN1BOOL unrestrictedVector;
+   ASN1BOOL arithmeticCoding;
+   ASN1BOOL advancedPrediction;
+   ASN1BOOL pbFrames;
+   ASN1BOOL temporalSpatialTradeOffCapability;
+   ASN1UINT hrd_B;
+   ASN1USINT bppMaxKb;
+   ASN1USINT slowSqcifMPI;
+   ASN1USINT slowQcifMPI;
+   ASN1USINT slowCifMPI;
+   ASN1USINT slowCif4MPI;
+   ASN1USINT slowCif16MPI;
+   ASN1BOOL errorCompensation;
+   H245EnhancementLayerInfo enhancementLayerInfo;
+   H245H263Options h263Options;
+} H245H263VideoCapability;
+
+EXTERN int asn1PE_H245H263VideoCapability (OOCTXT* pctxt, H245H263VideoCapability* pvalue);
+
+EXTERN int asn1PD_H245H263VideoCapability (OOCTXT* pctxt, H245H263VideoCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172VideoCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245IS11172VideoCapability {
+   struct {
+      unsigned videoBitRatePresent : 1;
+      unsigned vbvBufferSizePresent : 1;
+      unsigned samplesPerLinePresent : 1;
+      unsigned linesPerFramePresent : 1;
+      unsigned pictureRatePresent : 1;
+      unsigned luminanceSampleRatePresent : 1;
+      unsigned videoBadMBsCapPresent : 1;
+   } m;
+   ASN1BOOL constrainedBitstream;
+   ASN1UINT videoBitRate;
+   ASN1UINT vbvBufferSize;
+   ASN1USINT samplesPerLine;
+   ASN1USINT linesPerFrame;
+   ASN1UINT8 pictureRate;
+   ASN1UINT luminanceSampleRate;
+   ASN1BOOL videoBadMBsCap;
+} H245IS11172VideoCapability;
+
+EXTERN int asn1PE_H245IS11172VideoCapability (OOCTXT* pctxt, H245IS11172VideoCapability* pvalue);
+
+EXTERN int asn1PD_H245IS11172VideoCapability (OOCTXT* pctxt, H245IS11172VideoCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VideoCapability                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245VideoCapability_nonStandard 1
+#define T_H245VideoCapability_h261VideoCapability 2
+#define T_H245VideoCapability_h262VideoCapability 3
+#define T_H245VideoCapability_h263VideoCapability 4
+#define T_H245VideoCapability_is11172VideoCapability 5
+#define T_H245VideoCapability_genericVideoCapability 6
+#define T_H245VideoCapability_extElem1  7
+
+typedef struct EXTERN H245VideoCapability {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245H261VideoCapability *h261VideoCapability;
+      /* t = 3 */
+      H245H262VideoCapability *h262VideoCapability;
+      /* t = 4 */
+      H245H263VideoCapability *h263VideoCapability;
+      /* t = 5 */
+      H245IS11172VideoCapability *is11172VideoCapability;
+      /* t = 6 */
+      H245GenericCapability *genericVideoCapability;
+      /* t = 7 */
+   } u;
+} H245VideoCapability;
+
+EXTERN int asn1PE_H245VideoCapability (OOCTXT* pctxt, H245VideoCapability* pvalue);
+
+EXTERN int asn1PD_H245VideoCapability (OOCTXT* pctxt, H245VideoCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AudioCapability_g7231                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245AudioCapability_g7231 {
+   ASN1USINT maxAl_sduAudioFrames;
+   ASN1BOOL silenceSuppression;
+} H245AudioCapability_g7231;
+
+EXTERN int asn1PE_H245AudioCapability_g7231 (OOCTXT* pctxt, H245AudioCapability_g7231* pvalue);
+
+EXTERN int asn1PD_H245AudioCapability_g7231 (OOCTXT* pctxt, H245AudioCapability_g7231* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245IS11172AudioCapability {
+   ASN1BOOL audioLayer1;
+   ASN1BOOL audioLayer2;
+   ASN1BOOL audioLayer3;
+   ASN1BOOL audioSampling32k;
+   ASN1BOOL audioSampling44k1;
+   ASN1BOOL audioSampling48k;
+   ASN1BOOL singleChannel;
+   ASN1BOOL twoChannels;
+   ASN1USINT bitRate;
+} H245IS11172AudioCapability;
+
+EXTERN int asn1PE_H245IS11172AudioCapability (OOCTXT* pctxt, H245IS11172AudioCapability* pvalue);
+
+EXTERN int asn1PD_H245IS11172AudioCapability (OOCTXT* pctxt, H245IS11172AudioCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245IS13818AudioCapability {
+   ASN1BOOL audioLayer1;
+   ASN1BOOL audioLayer2;
+   ASN1BOOL audioLayer3;
+   ASN1BOOL audioSampling16k;
+   ASN1BOOL audioSampling22k05;
+   ASN1BOOL audioSampling24k;
+   ASN1BOOL audioSampling32k;
+   ASN1BOOL audioSampling44k1;
+   ASN1BOOL audioSampling48k;
+   ASN1BOOL singleChannel;
+   ASN1BOOL twoChannels;
+   ASN1BOOL threeChannels2_1;
+   ASN1BOOL threeChannels3_0;
+   ASN1BOOL fourChannels2_0_2_0;
+   ASN1BOOL fourChannels2_2;
+   ASN1BOOL fourChannels3_1;
+   ASN1BOOL fiveChannels3_0_2_0;
+   ASN1BOOL fiveChannels3_2;
+   ASN1BOOL lowFrequencyEnhancement;
+   ASN1BOOL multilingual;
+   ASN1USINT bitRate;
+} H245IS13818AudioCapability;
+
+EXTERN int asn1PE_H245IS13818AudioCapability (OOCTXT* pctxt, H245IS13818AudioCapability* pvalue);
+
+EXTERN int asn1PD_H245IS13818AudioCapability (OOCTXT* pctxt, H245IS13818AudioCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCCapability_g723AnnexCAudioMode                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245G7231AnnexCCapability_g723AnnexCAudioMode {
+   ASN1UINT8 highRateMode0;
+   ASN1UINT8 highRateMode1;
+   ASN1UINT8 lowRateMode0;
+   ASN1UINT8 lowRateMode1;
+   ASN1UINT8 sidMode0;
+   ASN1UINT8 sidMode1;
+} H245G7231AnnexCCapability_g723AnnexCAudioMode;
+
+EXTERN int asn1PE_H245G7231AnnexCCapability_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCCapability_g723AnnexCAudioMode* pvalue);
+
+EXTERN int asn1PD_H245G7231AnnexCCapability_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCCapability_g723AnnexCAudioMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCCapability                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245G7231AnnexCCapability {
+   struct {
+      unsigned g723AnnexCAudioModePresent : 1;
+   } m;
+   ASN1USINT maxAl_sduAudioFrames;
+   ASN1BOOL silenceSuppression;
+   H245G7231AnnexCCapability_g723AnnexCAudioMode g723AnnexCAudioMode;
+} H245G7231AnnexCCapability;
+
+EXTERN int asn1PE_H245G7231AnnexCCapability (OOCTXT* pctxt, H245G7231AnnexCCapability* pvalue);
+
+EXTERN int asn1PD_H245G7231AnnexCCapability (OOCTXT* pctxt, H245G7231AnnexCCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  GSMAudioCapability                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245GSMAudioCapability {
+   ASN1USINT audioUnitSize;
+   ASN1BOOL comfortNoise;
+   ASN1BOOL scrambled;
+} H245GSMAudioCapability;
+
+EXTERN int asn1PE_H245GSMAudioCapability (OOCTXT* pctxt, H245GSMAudioCapability* pvalue);
+
+EXTERN int asn1PD_H245GSMAudioCapability (OOCTXT* pctxt, H245GSMAudioCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  G729Extensions                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245G729Extensions {
+   struct {
+      unsigned audioUnitPresent : 1;
+   } m;
+   ASN1USINT audioUnit;
+   ASN1BOOL annexA;
+   ASN1BOOL annexB;
+   ASN1BOOL annexD;
+   ASN1BOOL annexE;
+   ASN1BOOL annexF;
+   ASN1BOOL annexG;
+   ASN1BOOL annexH;
+} H245G729Extensions;
+
+EXTERN int asn1PE_H245G729Extensions (OOCTXT* pctxt, H245G729Extensions* pvalue);
+
+EXTERN int asn1PD_H245G729Extensions (OOCTXT* pctxt, H245G729Extensions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VBDCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VBDCapability {
+   struct H245AudioCapability *type;
+} H245VBDCapability;
+
+EXTERN int asn1PE_H245VBDCapability (OOCTXT* pctxt, H245VBDCapability* pvalue);
+
+EXTERN int asn1PD_H245VBDCapability (OOCTXT* pctxt, H245VBDCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NoPTAudioTelephonyEventCapability                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NoPTAudioTelephonyEventCapability {
+   ASN1GeneralString audioTelephoneEvent;
+} H245NoPTAudioTelephonyEventCapability;
+
+EXTERN int asn1PE_H245NoPTAudioTelephonyEventCapability (OOCTXT* pctxt, H245NoPTAudioTelephonyEventCapability* pvalue);
+
+EXTERN int asn1PD_H245NoPTAudioTelephonyEventCapability (OOCTXT* pctxt, H245NoPTAudioTelephonyEventCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NoPTAudioToneCapability                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NoPTAudioToneCapability {
+   ASN1OCTET __dummy__;
+} H245NoPTAudioToneCapability;
+
+EXTERN int asn1PE_H245NoPTAudioToneCapability (OOCTXT* pctxt, H245NoPTAudioToneCapability* pvalue);
+
+EXTERN int asn1PD_H245NoPTAudioToneCapability (OOCTXT* pctxt, H245NoPTAudioToneCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AudioCapability                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245AudioCapability_nonStandard 1
+#define T_H245AudioCapability_g711Alaw64k 2
+#define T_H245AudioCapability_g711Alaw56k 3
+#define T_H245AudioCapability_g711Ulaw64k 4
+#define T_H245AudioCapability_g711Ulaw56k 5
+#define T_H245AudioCapability_g722_64k  6
+#define T_H245AudioCapability_g722_56k  7
+#define T_H245AudioCapability_g722_48k  8
+#define T_H245AudioCapability_g7231     9
+#define T_H245AudioCapability_g728      10
+#define T_H245AudioCapability_g729      11
+#define T_H245AudioCapability_g729AnnexA 12
+#define T_H245AudioCapability_is11172AudioCapability 13
+#define T_H245AudioCapability_is13818AudioCapability 14
+#define T_H245AudioCapability_g729wAnnexB 15
+#define T_H245AudioCapability_g729AnnexAwAnnexB 16
+#define T_H245AudioCapability_g7231AnnexCCapability 17
+#define T_H245AudioCapability_gsmFullRate 18
+#define T_H245AudioCapability_gsmHalfRate 19
+#define T_H245AudioCapability_gsmEnhancedFullRate 20
+#define T_H245AudioCapability_genericAudioCapability 21
+#define T_H245AudioCapability_g729Extensions 22
+#define T_H245AudioCapability_vbd       23
+#define T_H245AudioCapability_audioTelephonyEvent 24
+#define T_H245AudioCapability_audioTone 25
+#define T_H245AudioCapability_extElem1  26
+
+typedef struct EXTERN H245AudioCapability {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      ASN1USINT g711Alaw64k;
+      /* t = 3 */
+      ASN1USINT g711Alaw56k;
+      /* t = 4 */
+      ASN1USINT g711Ulaw64k;
+      /* t = 5 */
+      ASN1USINT g711Ulaw56k;
+      /* t = 6 */
+      ASN1USINT g722_64k;
+      /* t = 7 */
+      ASN1USINT g722_56k;
+      /* t = 8 */
+      ASN1USINT g722_48k;
+      /* t = 9 */
+      H245AudioCapability_g7231 *g7231;
+      /* t = 10 */
+      ASN1USINT g728;
+      /* t = 11 */
+      ASN1USINT g729;
+      /* t = 12 */
+      ASN1USINT g729AnnexA;
+      /* t = 13 */
+      H245IS11172AudioCapability *is11172AudioCapability;
+      /* t = 14 */
+      H245IS13818AudioCapability *is13818AudioCapability;
+      /* t = 15 */
+      ASN1USINT g729wAnnexB;
+      /* t = 16 */
+      ASN1USINT g729AnnexAwAnnexB;
+      /* t = 17 */
+      H245G7231AnnexCCapability *g7231AnnexCCapability;
+      /* t = 18 */
+      H245GSMAudioCapability *gsmFullRate;
+      /* t = 19 */
+      H245GSMAudioCapability *gsmHalfRate;
+      /* t = 20 */
+      H245GSMAudioCapability *gsmEnhancedFullRate;
+      /* t = 21 */
+      H245GenericCapability *genericAudioCapability;
+      /* t = 22 */
+      H245G729Extensions *g729Extensions;
+      /* t = 23 */
+      H245VBDCapability *vbd;
+      /* t = 24 */
+      H245NoPTAudioTelephonyEventCapability *audioTelephonyEvent;
+      /* t = 25 */
+      H245NoPTAudioToneCapability *audioTone;
+      /* t = 26 */
+   } u;
+} H245AudioCapability;
+
+EXTERN int asn1PE_H245AudioCapability (OOCTXT* pctxt, H245AudioCapability* pvalue);
+
+EXTERN int asn1PD_H245AudioCapability (OOCTXT* pctxt, H245AudioCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Capability_h233EncryptionReceiveCapability                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245Capability_h233EncryptionReceiveCapability {
+   ASN1UINT8 h233IVResponseTime;
+} H245Capability_h233EncryptionReceiveCapability;
+
+EXTERN int asn1PE_H245Capability_h233EncryptionReceiveCapability (OOCTXT* pctxt, H245Capability_h233EncryptionReceiveCapability* pvalue);
+
+EXTERN int asn1PD_H245Capability_h233EncryptionReceiveCapability (OOCTXT* pctxt, H245Capability_h233EncryptionReceiveCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245NonStandardParameter                            */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245NonStandardParameter */
+typedef DList H245_SeqOfH245NonStandardParameter;
+
+EXTERN int asn1PE_H245_SeqOfH245NonStandardParameter (OOCTXT* pctxt, H245_SeqOfH245NonStandardParameter* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245NonStandardParameter (OOCTXT* pctxt, H245_SeqOfH245NonStandardParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceCapability {
+   struct {
+      unsigned nonStandardDataPresent : 1;
+      unsigned videoIndicateMixingCapabilityPresent : 1;
+      unsigned multipointVisualizationCapabilityPresent : 1;
+   } m;
+   H245_SeqOfH245NonStandardParameter nonStandardData;
+   ASN1BOOL chairControlCapability;
+   ASN1BOOL videoIndicateMixingCapability;
+   ASN1BOOL multipointVisualizationCapability;
+} H245ConferenceCapability;
+
+EXTERN int asn1PE_H245ConferenceCapability (OOCTXT* pctxt, H245ConferenceCapability* pvalue);
+
+EXTERN int asn1PD_H245ConferenceCapability (OOCTXT* pctxt, H245ConferenceCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MediaEncryptionAlgorithm                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MediaEncryptionAlgorithm_nonStandard 1
+#define T_H245MediaEncryptionAlgorithm_algorithm 2
+#define T_H245MediaEncryptionAlgorithm_extElem1 3
+
+typedef struct EXTERN H245MediaEncryptionAlgorithm {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      ASN1OBJID *algorithm;
+      /* t = 3 */
+   } u;
+} H245MediaEncryptionAlgorithm;
+
+EXTERN int asn1PE_H245MediaEncryptionAlgorithm (OOCTXT* pctxt, H245MediaEncryptionAlgorithm* pvalue);
+
+EXTERN int asn1PD_H245MediaEncryptionAlgorithm (OOCTXT* pctxt, H245MediaEncryptionAlgorithm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MediaEncryptionAlgorithm */
+typedef DList H245EncryptionCapability;
+
+EXTERN int asn1PE_H245EncryptionCapability (OOCTXT* pctxt, H245EncryptionCapability* pvalue);
+
+EXTERN int asn1PD_H245EncryptionCapability (OOCTXT* pctxt, H245EncryptionCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationCapability                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245AuthenticationCapability {
+   struct {
+      unsigned nonStandardPresent : 1;
+      unsigned antiSpamAlgorithmPresent : 1;
+   } m;
+   H245NonStandardParameter nonStandard;
+   ASN1OBJID antiSpamAlgorithm;
+} H245AuthenticationCapability;
+
+EXTERN int asn1PE_H245AuthenticationCapability (OOCTXT* pctxt, H245AuthenticationCapability* pvalue);
+
+EXTERN int asn1PD_H245AuthenticationCapability (OOCTXT* pctxt, H245AuthenticationCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IntegrityCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245IntegrityCapability {
+   struct {
+      unsigned nonStandardPresent : 1;
+   } m;
+   H245NonStandardParameter nonStandard;
+} H245IntegrityCapability;
+
+EXTERN int asn1PE_H245IntegrityCapability (OOCTXT* pctxt, H245IntegrityCapability* pvalue);
+
+EXTERN int asn1PD_H245IntegrityCapability (OOCTXT* pctxt, H245IntegrityCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionAuthenticationAndIntegrity                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245EncryptionAuthenticationAndIntegrity {
+   struct {
+      unsigned encryptionCapabilityPresent : 1;
+      unsigned authenticationCapabilityPresent : 1;
+      unsigned integrityCapabilityPresent : 1;
+   } m;
+   H245EncryptionCapability encryptionCapability;
+   H245AuthenticationCapability authenticationCapability;
+   H245IntegrityCapability integrityCapability;
+} H245EncryptionAuthenticationAndIntegrity;
+
+EXTERN int asn1PE_H245EncryptionAuthenticationAndIntegrity (OOCTXT* pctxt, H245EncryptionAuthenticationAndIntegrity* pvalue);
+
+EXTERN int asn1PD_H245EncryptionAuthenticationAndIntegrity (OOCTXT* pctxt, H245EncryptionAuthenticationAndIntegrity* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H235SecurityCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H235SecurityCapability {
+   H245EncryptionAuthenticationAndIntegrity encryptionAuthenticationAndIntegrity;
+   H245CapabilityTableEntryNumber mediaCapability;
+} H245H235SecurityCapability;
+
+EXTERN int asn1PE_H245H235SecurityCapability (OOCTXT* pctxt, H245H235SecurityCapability* pvalue);
+
+EXTERN int asn1PD_H245H235SecurityCapability (OOCTXT* pctxt, H245H235SecurityCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputCapability_nonStandard                           */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245NonStandardParameter */
+typedef DList H245UserInputCapability_nonStandard;
+
+EXTERN int asn1PE_H245UserInputCapability_nonStandard (OOCTXT* pctxt, H245UserInputCapability_nonStandard* pvalue);
+
+EXTERN int asn1PD_H245UserInputCapability_nonStandard (OOCTXT* pctxt, H245UserInputCapability_nonStandard* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245UserInputCapability_nonStandard 1
+#define T_H245UserInputCapability_basicString 2
+#define T_H245UserInputCapability_iA5String 3
+#define T_H245UserInputCapability_generalString 4
+#define T_H245UserInputCapability_dtmf  5
+#define T_H245UserInputCapability_hookflash 6
+#define T_H245UserInputCapability_extendedAlphanumeric 7
+#define T_H245UserInputCapability_extElem1 8
+
+typedef struct EXTERN H245UserInputCapability {
+   int t;
+   union {
+      /* t = 1 */
+      H245UserInputCapability_nonStandard *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+   } u;
+} H245UserInputCapability;
+
+EXTERN int asn1PE_H245UserInputCapability (OOCTXT* pctxt, H245UserInputCapability* pvalue);
+
+EXTERN int asn1PD_H245UserInputCapability (OOCTXT* pctxt, H245UserInputCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexFormat                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultiplexFormat_nonStandard 1
+#define T_H245MultiplexFormat_h222Capability 2
+#define T_H245MultiplexFormat_h223Capability 3
+#define T_H245MultiplexFormat_extElem1  4
+
+typedef struct EXTERN H245MultiplexFormat {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245H222Capability *h222Capability;
+      /* t = 3 */
+      H245H223Capability *h223Capability;
+      /* t = 4 */
+   } u;
+} H245MultiplexFormat;
+
+EXTERN int asn1PE_H245MultiplexFormat (OOCTXT* pctxt, H245MultiplexFormat* pvalue);
+
+EXTERN int asn1PD_H245MultiplexFormat (OOCTXT* pctxt, H245MultiplexFormat* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AlternativeCapabilitySet                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245AlternativeCapabilitySet {
+   ASN1UINT n;
+   H245CapabilityTableEntryNumber elem[256];
+} H245AlternativeCapabilitySet;
+
+EXTERN int asn1PE_H245AlternativeCapabilitySet (OOCTXT* pctxt, H245AlternativeCapabilitySet* pvalue);
+
+EXTERN int asn1PD_H245AlternativeCapabilitySet (OOCTXT* pctxt, H245AlternativeCapabilitySet* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamCapability_capabilityOnMuxStream         */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245AlternativeCapabilitySet */
+typedef DList H245MultiplexedStreamCapability_capabilityOnMuxStream;
+
+EXTERN int asn1PE_H245MultiplexedStreamCapability_capabilityOnMuxStream (OOCTXT* pctxt, H245MultiplexedStreamCapability_capabilityOnMuxStream* pvalue);
+
+EXTERN int asn1PD_H245MultiplexedStreamCapability_capabilityOnMuxStream (OOCTXT* pctxt, H245MultiplexedStreamCapability_capabilityOnMuxStream* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamCapability                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexedStreamCapability {
+   struct {
+      unsigned capabilityOnMuxStreamPresent : 1;
+   } m;
+   H245MultiplexFormat multiplexFormat;
+   ASN1BOOL controlOnMuxStream;
+   H245MultiplexedStreamCapability_capabilityOnMuxStream capabilityOnMuxStream;
+} H245MultiplexedStreamCapability;
+
+EXTERN int asn1PE_H245MultiplexedStreamCapability (OOCTXT* pctxt, H245MultiplexedStreamCapability* pvalue);
+
+EXTERN int asn1PD_H245MultiplexedStreamCapability (OOCTXT* pctxt, H245MultiplexedStreamCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AudioTelephonyEventCapability                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245AudioTelephonyEventCapability {
+   ASN1UINT8 dynamicRTPPayloadType;
+   ASN1GeneralString audioTelephoneEvent;
+} H245AudioTelephonyEventCapability;
+
+EXTERN int asn1PE_H245AudioTelephonyEventCapability (OOCTXT* pctxt, H245AudioTelephonyEventCapability* pvalue);
+
+EXTERN int asn1PD_H245AudioTelephonyEventCapability (OOCTXT* pctxt, H245AudioTelephonyEventCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AudioToneCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245AudioToneCapability {
+   ASN1UINT8 dynamicRTPPayloadType;
+} H245AudioToneCapability;
+
+EXTERN int asn1PE_H245AudioToneCapability (OOCTXT* pctxt, H245AudioToneCapability* pvalue);
+
+EXTERN int asn1PD_H245AudioToneCapability (OOCTXT* pctxt, H245AudioToneCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability_rfc2733_separateStream                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FECCapability_rfc2733_separateStream {
+   ASN1BOOL separatePort;
+   ASN1BOOL samePort;
+} H245FECCapability_rfc2733_separateStream;
+
+EXTERN int asn1PE_H245FECCapability_rfc2733_separateStream (OOCTXT* pctxt, H245FECCapability_rfc2733_separateStream* pvalue);
+
+EXTERN int asn1PD_H245FECCapability_rfc2733_separateStream (OOCTXT* pctxt, H245FECCapability_rfc2733_separateStream* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability_rfc2733                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FECCapability_rfc2733 {
+   ASN1BOOL redundancyEncoding;
+   H245FECCapability_rfc2733_separateStream separateStream;
+} H245FECCapability_rfc2733;
+
+EXTERN int asn1PE_H245FECCapability_rfc2733 (OOCTXT* pctxt, H245FECCapability_rfc2733* pvalue);
+
+EXTERN int asn1PD_H245FECCapability_rfc2733 (OOCTXT* pctxt, H245FECCapability_rfc2733* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FECCapability_rfc2733     1
+#define T_H245FECCapability_extElem1    2
+
+typedef struct EXTERN H245FECCapability {
+   int t;
+   union {
+      /* t = 1 */
+      H245FECCapability_rfc2733 *rfc2733;
+      /* t = 2 */
+   } u;
+} H245FECCapability;
+
+EXTERN int asn1PE_H245FECCapability (OOCTXT* pctxt, H245FECCapability* pvalue);
+
+EXTERN int asn1PD_H245FECCapability (OOCTXT* pctxt, H245FECCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamCapability_capabilities              */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245AlternativeCapabilitySet */
+typedef DList H245MultiplePayloadStreamCapability_capabilities;
+
+EXTERN int asn1PE_H245MultiplePayloadStreamCapability_capabilities (OOCTXT* pctxt, H245MultiplePayloadStreamCapability_capabilities* pvalue);
+
+EXTERN int asn1PD_H245MultiplePayloadStreamCapability_capabilities (OOCTXT* pctxt, H245MultiplePayloadStreamCapability_capabilities* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamCapability                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplePayloadStreamCapability {
+   H245MultiplePayloadStreamCapability_capabilities capabilities;
+} H245MultiplePayloadStreamCapability;
+
+EXTERN int asn1PE_H245MultiplePayloadStreamCapability (OOCTXT* pctxt, H245MultiplePayloadStreamCapability* pvalue);
+
+EXTERN int asn1PD_H245MultiplePayloadStreamCapability (OOCTXT* pctxt, H245MultiplePayloadStreamCapability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Capability                                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245Capability_nonStandard    1
+#define T_H245Capability_receiveVideoCapability 2
+#define T_H245Capability_transmitVideoCapability 3
+#define T_H245Capability_receiveAndTransmitVideoCapability 4
+#define T_H245Capability_receiveAudioCapability 5
+#define T_H245Capability_transmitAudioCapability 6
+#define T_H245Capability_receiveAndTransmitAudioCapability 7
+#define T_H245Capability_receiveDataApplicationCapability 8
+#define T_H245Capability_transmitDataApplicationCapability 9
+#define T_H245Capability_receiveAndTransmitDataApplicationCapability 10
+#define T_H245Capability_h233EncryptionTransmitCapability 11
+#define T_H245Capability_h233EncryptionReceiveCapability 12
+#define T_H245Capability_conferenceCapability 13
+#define T_H245Capability_h235SecurityCapability 14
+#define T_H245Capability_maxPendingReplacementFor 15
+#define T_H245Capability_receiveUserInputCapability 16
+#define T_H245Capability_transmitUserInputCapability 17
+#define T_H245Capability_receiveAndTransmitUserInputCapability 18
+#define T_H245Capability_genericControlCapability 19
+#define T_H245Capability_receiveMultiplexedStreamCapability 20
+#define T_H245Capability_transmitMultiplexedStreamCapability 21
+#define T_H245Capability_receiveAndTransmitMultiplexedStreamCapability 22
+#define T_H245Capability_receiveRTPAudioTelephonyEventCapability 23
+#define T_H245Capability_receiveRTPAudioToneCapability 24
+#define T_H245Capability_fecCapability  25
+#define T_H245Capability_multiplePayloadStreamCapability 26
+#define T_H245Capability_extElem1       27
+
+typedef struct EXTERN H245Capability {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245VideoCapability *receiveVideoCapability;
+      /* t = 3 */
+      H245VideoCapability *transmitVideoCapability;
+      /* t = 4 */
+      H245VideoCapability *receiveAndTransmitVideoCapability;
+      /* t = 5 */
+      H245AudioCapability *receiveAudioCapability;
+      /* t = 6 */
+      H245AudioCapability *transmitAudioCapability;
+      /* t = 7 */
+      H245AudioCapability *receiveAndTransmitAudioCapability;
+      /* t = 8 */
+      H245DataApplicationCapability *receiveDataApplicationCapability;
+      /* t = 9 */
+      H245DataApplicationCapability *transmitDataApplicationCapability;
+      /* t = 10 */
+      H245DataApplicationCapability *receiveAndTransmitDataApplicationCapability;
+      /* t = 11 */
+      ASN1BOOL h233EncryptionTransmitCapability;
+      /* t = 12 */
+      H245Capability_h233EncryptionReceiveCapability *h233EncryptionReceiveCapability;
+      /* t = 13 */
+      H245ConferenceCapability *conferenceCapability;
+      /* t = 14 */
+      H245H235SecurityCapability *h235SecurityCapability;
+      /* t = 15 */
+      ASN1UINT8 maxPendingReplacementFor;
+      /* t = 16 */
+      H245UserInputCapability *receiveUserInputCapability;
+      /* t = 17 */
+      H245UserInputCapability *transmitUserInputCapability;
+      /* t = 18 */
+      H245UserInputCapability *receiveAndTransmitUserInputCapability;
+      /* t = 19 */
+      H245GenericCapability *genericControlCapability;
+      /* t = 20 */
+      H245MultiplexedStreamCapability *receiveMultiplexedStreamCapability;
+      /* t = 21 */
+      H245MultiplexedStreamCapability *transmitMultiplexedStreamCapability;
+      /* t = 22 */
+      H245MultiplexedStreamCapability *receiveAndTransmitMultiplexedStreamCapability;
+      /* t = 23 */
+      H245AudioTelephonyEventCapability *receiveRTPAudioTelephonyEventCapability;
+      /* t = 24 */
+      H245AudioToneCapability *receiveRTPAudioToneCapability;
+      /* t = 25 */
+      H245FECCapability *fecCapability;
+      /* t = 26 */
+      H245MultiplePayloadStreamCapability *multiplePayloadStreamCapability;
+      /* t = 27 */
+   } u;
+} H245Capability;
+
+EXTERN int asn1PE_H245Capability (OOCTXT* pctxt, H245Capability* pvalue);
+
+EXTERN int asn1PD_H245Capability (OOCTXT* pctxt, H245Capability* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityTableEntry                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CapabilityTableEntry {
+   struct {
+      unsigned capabilityPresent : 1;
+   } m;
+   H245CapabilityTableEntryNumber capabilityTableEntryNumber;
+   H245Capability capability;
+} H245CapabilityTableEntry;
+
+EXTERN int asn1PE_H245CapabilityTableEntry (OOCTXT* pctxt, H245CapabilityTableEntry* pvalue);
+
+EXTERN int asn1PD_H245CapabilityTableEntry (OOCTXT* pctxt, H245CapabilityTableEntry* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet_capabilityTable                     */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245CapabilityTableEntry */
+typedef DList H245TerminalCapabilitySet_capabilityTable;
+
+EXTERN int asn1PE_H245TerminalCapabilitySet_capabilityTable (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityTable* pvalue);
+
+EXTERN int asn1PD_H245TerminalCapabilitySet_capabilityTable (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityTable* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptorNumber                                */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT8 H245CapabilityDescriptorNumber;
+
+EXTERN int asn1PE_H245CapabilityDescriptorNumber (OOCTXT* pctxt, H245CapabilityDescriptorNumber value);
+
+EXTERN int asn1PD_H245CapabilityDescriptorNumber (OOCTXT* pctxt, H245CapabilityDescriptorNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptor_simultaneousCapabilities             */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245AlternativeCapabilitySet */
+typedef DList H245CapabilityDescriptor_simultaneousCapabilities;
+
+EXTERN int asn1PE_H245CapabilityDescriptor_simultaneousCapabilities (OOCTXT* pctxt, H245CapabilityDescriptor_simultaneousCapabilities* pvalue);
+
+EXTERN int asn1PD_H245CapabilityDescriptor_simultaneousCapabilities (OOCTXT* pctxt, H245CapabilityDescriptor_simultaneousCapabilities* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptor                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CapabilityDescriptor {
+   struct {
+      unsigned simultaneousCapabilitiesPresent : 1;
+   } m;
+   H245CapabilityDescriptorNumber capabilityDescriptorNumber;
+   H245CapabilityDescriptor_simultaneousCapabilities simultaneousCapabilities;
+} H245CapabilityDescriptor;
+
+EXTERN int asn1PE_H245CapabilityDescriptor (OOCTXT* pctxt, H245CapabilityDescriptor* pvalue);
+
+EXTERN int asn1PD_H245CapabilityDescriptor (OOCTXT* pctxt, H245CapabilityDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet_capabilityDescriptors               */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245CapabilityDescriptor */
+typedef DList H245TerminalCapabilitySet_capabilityDescriptors;
+
+EXTERN int asn1PE_H245TerminalCapabilitySet_capabilityDescriptors (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityDescriptors* pvalue);
+
+EXTERN int asn1PD_H245TerminalCapabilitySet_capabilityDescriptors (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityDescriptors* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TerminalCapabilitySet {
+   struct {
+      unsigned multiplexCapabilityPresent : 1;
+      unsigned capabilityTablePresent : 1;
+      unsigned capabilityDescriptorsPresent : 1;
+   } m;
+   H245SequenceNumber sequenceNumber;
+   ASN1OBJID protocolIdentifier;
+   H245MultiplexCapability multiplexCapability;
+   H245TerminalCapabilitySet_capabilityTable capabilityTable;
+   H245TerminalCapabilitySet_capabilityDescriptors capabilityDescriptors;
+} H245TerminalCapabilitySet;
+
+EXTERN int asn1PE_H245TerminalCapabilitySet (OOCTXT* pctxt, H245TerminalCapabilitySet* pvalue);
+
+EXTERN int asn1PD_H245TerminalCapabilitySet (OOCTXT* pctxt, H245TerminalCapabilitySet* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelNumber                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1USINT H245LogicalChannelNumber;
+
+EXTERN int asn1PE_H245LogicalChannelNumber (OOCTXT* pctxt, H245LogicalChannelNumber value);
+
+EXTERN int asn1PD_H245LogicalChannelNumber (OOCTXT* pctxt, H245LogicalChannelNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionMode                                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245EncryptionMode_nonStandard 1
+#define T_H245EncryptionMode_h233Encryption 2
+#define T_H245EncryptionMode_extElem1   3
+
+typedef struct EXTERN H245EncryptionMode {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+   } u;
+} H245EncryptionMode;
+
+EXTERN int asn1PE_H245EncryptionMode (OOCTXT* pctxt, H245EncryptionMode* pvalue);
+
+EXTERN int asn1PD_H245EncryptionMode (OOCTXT* pctxt, H245EncryptionMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingElement                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RedundancyEncodingElement {
+   struct {
+      unsigned payloadTypePresent : 1;
+   } m;
+   struct H245DataType *dataType;
+   ASN1UINT8 payloadType;
+} H245RedundancyEncodingElement;
+
+EXTERN int asn1PE_H245RedundancyEncodingElement (OOCTXT* pctxt, H245RedundancyEncodingElement* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingElement (OOCTXT* pctxt, H245RedundancyEncodingElement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245RedundancyEncodingElement                       */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245RedundancyEncodingElement */
+typedef DList H245_SeqOfH245RedundancyEncodingElement;
+
+EXTERN int asn1PE_H245_SeqOfH245RedundancyEncodingElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingElement* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245RedundancyEncodingElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingElement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncoding_rtpRedundancyEncoding                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RedundancyEncoding_rtpRedundancyEncoding {
+   struct {
+      unsigned primaryPresent : 1;
+      unsigned secondaryPresent : 1;
+   } m;
+   H245RedundancyEncodingElement primary;
+   H245_SeqOfH245RedundancyEncodingElement secondary;
+} H245RedundancyEncoding_rtpRedundancyEncoding;
+
+EXTERN int asn1PE_H245RedundancyEncoding_rtpRedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding_rtpRedundancyEncoding* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncoding_rtpRedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding_rtpRedundancyEncoding* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncoding                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RedundancyEncoding {
+   struct {
+      unsigned secondaryEncodingPresent : 1;
+      unsigned rtpRedundancyEncodingPresent : 1;
+   } m;
+   H245RedundancyEncodingMethod redundancyEncodingMethod;
+   struct H245DataType *secondaryEncoding;
+   H245RedundancyEncoding_rtpRedundancyEncoding rtpRedundancyEncoding;
+} H245RedundancyEncoding;
+
+EXTERN int asn1PE_H245RedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamElement                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplePayloadStreamElement {
+   struct {
+      unsigned payloadTypePresent : 1;
+   } m;
+   struct H245DataType *dataType;
+   ASN1UINT8 payloadType;
+} H245MultiplePayloadStreamElement;
+
+EXTERN int asn1PE_H245MultiplePayloadStreamElement (OOCTXT* pctxt, H245MultiplePayloadStreamElement* pvalue);
+
+EXTERN int asn1PD_H245MultiplePayloadStreamElement (OOCTXT* pctxt, H245MultiplePayloadStreamElement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MultiplePayloadStreamElement                    */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MultiplePayloadStreamElement */
+typedef DList H245_SeqOfH245MultiplePayloadStreamElement;
+
+EXTERN int asn1PE_H245_SeqOfH245MultiplePayloadStreamElement (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElement* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245MultiplePayloadStreamElement (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStream                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplePayloadStream {
+   H245_SeqOfH245MultiplePayloadStreamElement elements;
+} H245MultiplePayloadStream;
+
+EXTERN int asn1PE_H245MultiplePayloadStream (OOCTXT* pctxt, H245MultiplePayloadStream* pvalue);
+
+EXTERN int asn1PD_H245MultiplePayloadStream (OOCTXT* pctxt, H245MultiplePayloadStream* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream_differentPort         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FECData_rfc2733_mode_separateStream_differentPort {
+   struct {
+      unsigned protectedPayloadTypePresent : 1;
+   } m;
+   ASN1UINT8 protectedSessionID;
+   ASN1UINT8 protectedPayloadType;
+} H245FECData_rfc2733_mode_separateStream_differentPort;
+
+EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_differentPort* pvalue);
+
+EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_differentPort* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream_samePort              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FECData_rfc2733_mode_separateStream_samePort {
+   ASN1UINT8 protectedPayloadType;
+} H245FECData_rfc2733_mode_separateStream_samePort;
+
+EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream_samePort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_samePort* pvalue);
+
+EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream_samePort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_samePort* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FECData_rfc2733_mode_separateStream_differentPort 1
+#define T_H245FECData_rfc2733_mode_separateStream_samePort 2
+#define T_H245FECData_rfc2733_mode_separateStream_extElem1 3
+
+typedef struct EXTERN H245FECData_rfc2733_mode_separateStream {
+   int t;
+   union {
+      /* t = 1 */
+      H245FECData_rfc2733_mode_separateStream_differentPort *differentPort;
+      /* t = 2 */
+      H245FECData_rfc2733_mode_separateStream_samePort *samePort;
+      /* t = 3 */
+   } u;
+} H245FECData_rfc2733_mode_separateStream;
+
+EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream* pvalue);
+
+EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FECData_rfc2733_mode_redundancyEncoding 1
+#define T_H245FECData_rfc2733_mode_separateStream 2
+#define T_H245FECData_rfc2733_mode_extElem1 3
+
+typedef struct EXTERN H245FECData_rfc2733_mode {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245FECData_rfc2733_mode_separateStream *separateStream;
+      /* t = 3 */
+   } u;
+} H245FECData_rfc2733_mode;
+
+EXTERN int asn1PE_H245FECData_rfc2733_mode (OOCTXT* pctxt, H245FECData_rfc2733_mode* pvalue);
+
+EXTERN int asn1PD_H245FECData_rfc2733_mode (OOCTXT* pctxt, H245FECData_rfc2733_mode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FECData_rfc2733 {
+   H245FECData_rfc2733_mode mode;
+} H245FECData_rfc2733;
+
+EXTERN int asn1PE_H245FECData_rfc2733 (OOCTXT* pctxt, H245FECData_rfc2733* pvalue);
+
+EXTERN int asn1PD_H245FECData_rfc2733 (OOCTXT* pctxt, H245FECData_rfc2733* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECData                                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FECData_rfc2733           1
+
+typedef struct EXTERN H245FECData {
+   int t;
+   union {
+      /* t = 1 */
+      H245FECData_rfc2733 *rfc2733;
+   } u;
+} H245FECData;
+
+EXTERN int asn1PE_H245FECData (OOCTXT* pctxt, H245FECData* pvalue);
+
+EXTERN int asn1PD_H245FECData (OOCTXT* pctxt, H245FECData* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H235Media_mediaType                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H235Media_mediaType_nonStandard 1
+#define T_H245H235Media_mediaType_videoData 2
+#define T_H245H235Media_mediaType_audioData 3
+#define T_H245H235Media_mediaType_data  4
+#define T_H245H235Media_mediaType_redundancyEncoding 5
+#define T_H245H235Media_mediaType_multiplePayloadStream 6
+#define T_H245H235Media_mediaType_fec   7
+#define T_H245H235Media_mediaType_extElem1 8
+
+typedef struct EXTERN H245H235Media_mediaType {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245VideoCapability *videoData;
+      /* t = 3 */
+      H245AudioCapability *audioData;
+      /* t = 4 */
+      H245DataApplicationCapability *data;
+      /* t = 5 */
+      H245RedundancyEncoding *redundancyEncoding;
+      /* t = 6 */
+      H245MultiplePayloadStream *multiplePayloadStream;
+      /* t = 7 */
+      H245FECData *fec;
+      /* t = 8 */
+   } u;
+} H245H235Media_mediaType;
+
+EXTERN int asn1PE_H245H235Media_mediaType (OOCTXT* pctxt, H245H235Media_mediaType* pvalue);
+
+EXTERN int asn1PD_H245H235Media_mediaType (OOCTXT* pctxt, H245H235Media_mediaType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H235Media                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H235Media {
+   H245EncryptionAuthenticationAndIntegrity encryptionAuthenticationAndIntegrity;
+   H245H235Media_mediaType mediaType;
+} H245H235Media;
+
+EXTERN int asn1PE_H245H235Media (OOCTXT* pctxt, H245H235Media* pvalue);
+
+EXTERN int asn1PD_H245H235Media (OOCTXT* pctxt, H245H235Media* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamParameter                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexedStreamParameter {
+   H245MultiplexFormat multiplexFormat;
+   ASN1BOOL controlOnMuxStream;
+} H245MultiplexedStreamParameter;
+
+EXTERN int asn1PE_H245MultiplexedStreamParameter (OOCTXT* pctxt, H245MultiplexedStreamParameter* pvalue);
+
+EXTERN int asn1PD_H245MultiplexedStreamParameter (OOCTXT* pctxt, H245MultiplexedStreamParameter* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataType                                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245DataType_nonStandard      1
+#define T_H245DataType_nullData         2
+#define T_H245DataType_videoData        3
+#define T_H245DataType_audioData        4
+#define T_H245DataType_data             5
+#define T_H245DataType_encryptionData   6
+#define T_H245DataType_h235Control      7
+#define T_H245DataType_h235Media        8
+#define T_H245DataType_multiplexedStream 9
+#define T_H245DataType_redundancyEncoding 10
+#define T_H245DataType_multiplePayloadStream 11
+#define T_H245DataType_fec              12
+#define T_H245DataType_extElem1         13
+
+typedef struct EXTERN H245DataType {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      H245VideoCapability *videoData;
+      /* t = 4 */
+      H245AudioCapability *audioData;
+      /* t = 5 */
+      H245DataApplicationCapability *data;
+      /* t = 6 */
+      H245EncryptionMode *encryptionData;
+      /* t = 7 */
+      H245NonStandardParameter *h235Control;
+      /* t = 8 */
+      H245H235Media *h235Media;
+      /* t = 9 */
+      H245MultiplexedStreamParameter *multiplexedStream;
+      /* t = 10 */
+      H245RedundancyEncoding *redundancyEncoding;
+      /* t = 11 */
+      H245MultiplePayloadStream *multiplePayloadStream;
+      /* t = 12 */
+      H245FECData *fec;
+      /* t = 13 */
+   } u;
+} H245DataType;
+
+EXTERN int asn1PE_H245DataType (OOCTXT* pctxt, H245DataType* pvalue);
+
+EXTERN int asn1PD_H245DataType (OOCTXT* pctxt, H245DataType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H222LogicalChannelParameters                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H222LogicalChannelParameters {
+   struct {
+      unsigned pcr_pidPresent : 1;
+      unsigned programDescriptorsPresent : 1;
+      unsigned streamDescriptorsPresent : 1;
+   } m;
+   ASN1USINT resourceID;
+   ASN1USINT subChannelID;
+   ASN1USINT pcr_pid;
+   ASN1DynOctStr programDescriptors;
+   ASN1DynOctStr streamDescriptors;
+} H245H222LogicalChannelParameters;
+
+EXTERN int asn1PE_H245H222LogicalChannelParameters (OOCTXT* pctxt, H245H222LogicalChannelParameters* pvalue);
+
+EXTERN int asn1PD_H245H222LogicalChannelParameters (OOCTXT* pctxt, H245H222LogicalChannelParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters_adaptationLayerType_al3      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223LogicalChannelParameters_adaptationLayerType_al3 {
+   ASN1UINT8 controlFieldOctets;
+   ASN1UINT sendBufferSize;
+} H245H223LogicalChannelParameters_adaptationLayerType_al3;
+
+EXTERN int asn1PE_H245H223LogicalChannelParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3* pvalue);
+
+EXTERN int asn1PD_H245H223LogicalChannelParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_transferMode                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AL1MParameters_transferMode_framed 1
+#define T_H245H223AL1MParameters_transferMode_unframed 2
+#define T_H245H223AL1MParameters_transferMode_extElem1 3
+
+typedef struct EXTERN H245H223AL1MParameters_transferMode {
+   int t;
+} H245H223AL1MParameters_transferMode;
+
+EXTERN int asn1PE_H245H223AL1MParameters_transferMode (OOCTXT* pctxt, H245H223AL1MParameters_transferMode* pvalue);
+
+EXTERN int asn1PD_H245H223AL1MParameters_transferMode (OOCTXT* pctxt, H245H223AL1MParameters_transferMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_headerFEC                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AL1MParameters_headerFEC_sebch16_7 1
+#define T_H245H223AL1MParameters_headerFEC_golay24_12 2
+#define T_H245H223AL1MParameters_headerFEC_extElem1 3
+
+typedef struct EXTERN H245H223AL1MParameters_headerFEC {
+   int t;
+} H245H223AL1MParameters_headerFEC;
+
+EXTERN int asn1PE_H245H223AL1MParameters_headerFEC (OOCTXT* pctxt, H245H223AL1MParameters_headerFEC* pvalue);
+
+EXTERN int asn1PD_H245H223AL1MParameters_headerFEC (OOCTXT* pctxt, H245H223AL1MParameters_headerFEC* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_crcLength                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AL1MParameters_crcLength_crc4bit 1
+#define T_H245H223AL1MParameters_crcLength_crc12bit 2
+#define T_H245H223AL1MParameters_crcLength_crc20bit 3
+#define T_H245H223AL1MParameters_crcLength_crc28bit 4
+#define T_H245H223AL1MParameters_crcLength_crc8bit 5
+#define T_H245H223AL1MParameters_crcLength_crc16bit 6
+#define T_H245H223AL1MParameters_crcLength_crc32bit 7
+#define T_H245H223AL1MParameters_crcLength_crcNotUsed 8
+#define T_H245H223AL1MParameters_crcLength_extElem1 9
+
+typedef struct EXTERN H245H223AL1MParameters_crcLength {
+   int t;
+} H245H223AL1MParameters_crcLength;
+
+EXTERN int asn1PE_H245H223AL1MParameters_crcLength (OOCTXT* pctxt, H245H223AL1MParameters_crcLength* pvalue);
+
+EXTERN int asn1PD_H245H223AL1MParameters_crcLength (OOCTXT* pctxt, H245H223AL1MParameters_crcLength* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AnnexCArqParameters_numberOfRetransmissions           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AnnexCArqParameters_numberOfRetransmissions_finite 1
+#define T_H245H223AnnexCArqParameters_numberOfRetransmissions_infinite 2
+#define T_H245H223AnnexCArqParameters_numberOfRetransmissions_extElem1 3
+
+typedef struct EXTERN H245H223AnnexCArqParameters_numberOfRetransmissions {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1UINT8 finite;
+      /* t = 2 */
+      /* t = 3 */
+   } u;
+} H245H223AnnexCArqParameters_numberOfRetransmissions;
+
+EXTERN int asn1PE_H245H223AnnexCArqParameters_numberOfRetransmissions (OOCTXT* pctxt, H245H223AnnexCArqParameters_numberOfRetransmissions* pvalue);
+
+EXTERN int asn1PD_H245H223AnnexCArqParameters_numberOfRetransmissions (OOCTXT* pctxt, H245H223AnnexCArqParameters_numberOfRetransmissions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AnnexCArqParameters                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223AnnexCArqParameters {
+   H245H223AnnexCArqParameters_numberOfRetransmissions numberOfRetransmissions;
+   ASN1UINT sendBufferSize;
+} H245H223AnnexCArqParameters;
+
+EXTERN int asn1PE_H245H223AnnexCArqParameters (OOCTXT* pctxt, H245H223AnnexCArqParameters* pvalue);
+
+EXTERN int asn1PD_H245H223AnnexCArqParameters (OOCTXT* pctxt, H245H223AnnexCArqParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_arqType                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AL1MParameters_arqType_noArq 1
+#define T_H245H223AL1MParameters_arqType_typeIArq 2
+#define T_H245H223AL1MParameters_arqType_typeIIArq 3
+#define T_H245H223AL1MParameters_arqType_extElem1 4
+
+typedef struct EXTERN H245H223AL1MParameters_arqType {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245H223AnnexCArqParameters *typeIArq;
+      /* t = 3 */
+      H245H223AnnexCArqParameters *typeIIArq;
+      /* t = 4 */
+   } u;
+} H245H223AL1MParameters_arqType;
+
+EXTERN int asn1PE_H245H223AL1MParameters_arqType (OOCTXT* pctxt, H245H223AL1MParameters_arqType* pvalue);
+
+EXTERN int asn1PD_H245H223AL1MParameters_arqType (OOCTXT* pctxt, H245H223AL1MParameters_arqType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223AL1MParameters {
+   struct {
+      unsigned rsCodeCorrectionPresent : 1;
+   } m;
+   H245H223AL1MParameters_transferMode transferMode;
+   H245H223AL1MParameters_headerFEC headerFEC;
+   H245H223AL1MParameters_crcLength crcLength;
+   ASN1UINT8 rcpcCodeRate;
+   H245H223AL1MParameters_arqType arqType;
+   ASN1BOOL alpduInterleaving;
+   ASN1BOOL alsduSplitting;
+   ASN1UINT8 rsCodeCorrection;
+} H245H223AL1MParameters;
+
+EXTERN int asn1PE_H245H223AL1MParameters (OOCTXT* pctxt, H245H223AL1MParameters* pvalue);
+
+EXTERN int asn1PD_H245H223AL1MParameters (OOCTXT* pctxt, H245H223AL1MParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL2MParameters_headerFEC                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AL2MParameters_headerFEC_sebch16_5 1
+#define T_H245H223AL2MParameters_headerFEC_golay24_12 2
+#define T_H245H223AL2MParameters_headerFEC_extElem1 3
+
+typedef struct EXTERN H245H223AL2MParameters_headerFEC {
+   int t;
+} H245H223AL2MParameters_headerFEC;
+
+EXTERN int asn1PE_H245H223AL2MParameters_headerFEC (OOCTXT* pctxt, H245H223AL2MParameters_headerFEC* pvalue);
+
+EXTERN int asn1PD_H245H223AL2MParameters_headerFEC (OOCTXT* pctxt, H245H223AL2MParameters_headerFEC* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL2MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223AL2MParameters {
+   H245H223AL2MParameters_headerFEC headerFEC;
+   ASN1BOOL alpduInterleaving;
+} H245H223AL2MParameters;
+
+EXTERN int asn1PE_H245H223AL2MParameters (OOCTXT* pctxt, H245H223AL2MParameters* pvalue);
+
+EXTERN int asn1PD_H245H223AL2MParameters (OOCTXT* pctxt, H245H223AL2MParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_headerFormat                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AL3MParameters_headerFormat_sebch16_7 1
+#define T_H245H223AL3MParameters_headerFormat_golay24_12 2
+#define T_H245H223AL3MParameters_headerFormat_extElem1 3
+
+typedef struct EXTERN H245H223AL3MParameters_headerFormat {
+   int t;
+} H245H223AL3MParameters_headerFormat;
+
+EXTERN int asn1PE_H245H223AL3MParameters_headerFormat (OOCTXT* pctxt, H245H223AL3MParameters_headerFormat* pvalue);
+
+EXTERN int asn1PD_H245H223AL3MParameters_headerFormat (OOCTXT* pctxt, H245H223AL3MParameters_headerFormat* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_crcLength                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AL3MParameters_crcLength_crc4bit 1
+#define T_H245H223AL3MParameters_crcLength_crc12bit 2
+#define T_H245H223AL3MParameters_crcLength_crc20bit 3
+#define T_H245H223AL3MParameters_crcLength_crc28bit 4
+#define T_H245H223AL3MParameters_crcLength_crc8bit 5
+#define T_H245H223AL3MParameters_crcLength_crc16bit 6
+#define T_H245H223AL3MParameters_crcLength_crc32bit 7
+#define T_H245H223AL3MParameters_crcLength_crcNotUsed 8
+#define T_H245H223AL3MParameters_crcLength_extElem1 9
+
+typedef struct EXTERN H245H223AL3MParameters_crcLength {
+   int t;
+} H245H223AL3MParameters_crcLength;
+
+EXTERN int asn1PE_H245H223AL3MParameters_crcLength (OOCTXT* pctxt, H245H223AL3MParameters_crcLength* pvalue);
+
+EXTERN int asn1PD_H245H223AL3MParameters_crcLength (OOCTXT* pctxt, H245H223AL3MParameters_crcLength* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_arqType                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223AL3MParameters_arqType_noArq 1
+#define T_H245H223AL3MParameters_arqType_typeIArq 2
+#define T_H245H223AL3MParameters_arqType_typeIIArq 3
+#define T_H245H223AL3MParameters_arqType_extElem1 4
+
+typedef struct EXTERN H245H223AL3MParameters_arqType {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245H223AnnexCArqParameters *typeIArq;
+      /* t = 3 */
+      H245H223AnnexCArqParameters *typeIIArq;
+      /* t = 4 */
+   } u;
+} H245H223AL3MParameters_arqType;
+
+EXTERN int asn1PE_H245H223AL3MParameters_arqType (OOCTXT* pctxt, H245H223AL3MParameters_arqType* pvalue);
+
+EXTERN int asn1PD_H245H223AL3MParameters_arqType (OOCTXT* pctxt, H245H223AL3MParameters_arqType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223AL3MParameters {
+   struct {
+      unsigned rsCodeCorrectionPresent : 1;
+   } m;
+   H245H223AL3MParameters_headerFormat headerFormat;
+   H245H223AL3MParameters_crcLength crcLength;
+   ASN1UINT8 rcpcCodeRate;
+   H245H223AL3MParameters_arqType arqType;
+   ASN1BOOL alpduInterleaving;
+   ASN1UINT8 rsCodeCorrection;
+} H245H223AL3MParameters;
+
+EXTERN int asn1PE_H245H223AL3MParameters (OOCTXT* pctxt, H245H223AL3MParameters* pvalue);
+
+EXTERN int asn1PD_H245H223AL3MParameters (OOCTXT* pctxt, H245H223AL3MParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters_adaptationLayerType          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_nonStandard 1
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_al1Framed 2
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_al1NotFramed 3
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_al2WithoutSequenceNumbers 4
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_al2WithSequenceNumbers 5
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_al3 6
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_al1M 7
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_al2M 8
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_al3M 9
+#define T_H245H223LogicalChannelParameters_adaptationLayerType_extElem1 10
+
+typedef struct EXTERN H245H223LogicalChannelParameters_adaptationLayerType {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      H245H223LogicalChannelParameters_adaptationLayerType_al3 *al3;
+      /* t = 7 */
+      H245H223AL1MParameters *al1M;
+      /* t = 8 */
+      H245H223AL2MParameters *al2M;
+      /* t = 9 */
+      H245H223AL3MParameters *al3M;
+      /* t = 10 */
+   } u;
+} H245H223LogicalChannelParameters_adaptationLayerType;
+
+EXTERN int asn1PE_H245H223LogicalChannelParameters_adaptationLayerType (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType* pvalue);
+
+EXTERN int asn1PD_H245H223LogicalChannelParameters_adaptationLayerType (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223LogicalChannelParameters {
+   H245H223LogicalChannelParameters_adaptationLayerType adaptationLayerType;
+   ASN1BOOL segmentableFlag;
+} H245H223LogicalChannelParameters;
+
+EXTERN int asn1PE_H245H223LogicalChannelParameters (OOCTXT* pctxt, H245H223LogicalChannelParameters* pvalue);
+
+EXTERN int asn1PD_H245H223LogicalChannelParameters (OOCTXT* pctxt, H245H223LogicalChannelParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CRCLength                                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CRCLength_crc8bit         1
+#define T_H245CRCLength_crc16bit        2
+#define T_H245CRCLength_crc32bit        3
+#define T_H245CRCLength_extElem1        4
+
+typedef struct EXTERN H245CRCLength {
+   int t;
+} H245CRCLength;
+
+EXTERN int asn1PE_H245CRCLength (OOCTXT* pctxt, H245CRCLength* pvalue);
+
+EXTERN int asn1PD_H245CRCLength (OOCTXT* pctxt, H245CRCLength* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V76HDLCParameters                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245V76HDLCParameters {
+   H245CRCLength crcLength;
+   ASN1USINT n401;
+   ASN1BOOL loopbackTestProcedure;
+} H245V76HDLCParameters;
+
+EXTERN int asn1PE_H245V76HDLCParameters (OOCTXT* pctxt, H245V76HDLCParameters* pvalue);
+
+EXTERN int asn1PD_H245V76HDLCParameters (OOCTXT* pctxt, H245V76HDLCParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_suspendResume                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245V76LogicalChannelParameters_suspendResume_noSuspendResume 1
+#define T_H245V76LogicalChannelParameters_suspendResume_suspendResumewAddress 2
+#define T_H245V76LogicalChannelParameters_suspendResume_suspendResumewoAddress 3
+#define T_H245V76LogicalChannelParameters_suspendResume_extElem1 4
+
+typedef struct EXTERN H245V76LogicalChannelParameters_suspendResume {
+   int t;
+} H245V76LogicalChannelParameters_suspendResume;
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters_suspendResume (OOCTXT* pctxt, H245V76LogicalChannelParameters_suspendResume* pvalue);
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters_suspendResume (OOCTXT* pctxt, H245V76LogicalChannelParameters_suspendResume* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode_eRM_recovery             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245V76LogicalChannelParameters_mode_eRM_recovery_rej 1
+#define T_H245V76LogicalChannelParameters_mode_eRM_recovery_sREJ 2
+#define T_H245V76LogicalChannelParameters_mode_eRM_recovery_mSREJ 3
+#define T_H245V76LogicalChannelParameters_mode_eRM_recovery_extElem1 4
+
+typedef struct EXTERN H245V76LogicalChannelParameters_mode_eRM_recovery {
+   int t;
+} H245V76LogicalChannelParameters_mode_eRM_recovery;
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters_mode_eRM_recovery (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM_recovery* pvalue);
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters_mode_eRM_recovery (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM_recovery* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode_eRM                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245V76LogicalChannelParameters_mode_eRM {
+   ASN1UINT8 windowSize;
+   H245V76LogicalChannelParameters_mode_eRM_recovery recovery;
+} H245V76LogicalChannelParameters_mode_eRM;
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters_mode_eRM (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM* pvalue);
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters_mode_eRM (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245V76LogicalChannelParameters_mode_eRM 1
+#define T_H245V76LogicalChannelParameters_mode_uNERM 2
+#define T_H245V76LogicalChannelParameters_mode_extElem1 3
+
+typedef struct EXTERN H245V76LogicalChannelParameters_mode {
+   int t;
+   union {
+      /* t = 1 */
+      H245V76LogicalChannelParameters_mode_eRM *eRM;
+      /* t = 2 */
+      /* t = 3 */
+   } u;
+} H245V76LogicalChannelParameters_mode;
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters_mode (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode* pvalue);
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters_mode (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V75Parameters                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245V75Parameters {
+   ASN1BOOL audioHeaderPresent;
+} H245V75Parameters;
+
+EXTERN int asn1PE_H245V75Parameters (OOCTXT* pctxt, H245V75Parameters* pvalue);
+
+EXTERN int asn1PD_H245V75Parameters (OOCTXT* pctxt, H245V75Parameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245V76LogicalChannelParameters {
+   H245V76HDLCParameters hdlcParameters;
+   H245V76LogicalChannelParameters_suspendResume suspendResume;
+   ASN1BOOL uIH;
+   H245V76LogicalChannelParameters_mode mode;
+   H245V75Parameters v75Parameters;
+} H245V76LogicalChannelParameters;
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters (OOCTXT* pctxt, H245V76LogicalChannelParameters* pvalue);
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters (OOCTXT* pctxt, H245V76LogicalChannelParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPAddress_network                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPAddress_network {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H245UnicastAddress_iPAddress_network;
+
+EXTERN int asn1PE_H245UnicastAddress_iPAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPAddress_network* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPAddress_network* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPAddress                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPAddress {
+   H245UnicastAddress_iPAddress_network network;
+   ASN1USINT tsapIdentifier;
+} H245UnicastAddress_iPAddress;
+
+EXTERN int asn1PE_H245UnicastAddress_iPAddress (OOCTXT* pctxt, H245UnicastAddress_iPAddress* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPAddress (OOCTXT* pctxt, H245UnicastAddress_iPAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_node                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPXAddress_node {
+   ASN1UINT numocts;
+   ASN1OCTET data[6];
+} H245UnicastAddress_iPXAddress_node;
+
+EXTERN int asn1PE_H245UnicastAddress_iPXAddress_node (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_node* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPXAddress_node (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_node* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_netnum                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPXAddress_netnum {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H245UnicastAddress_iPXAddress_netnum;
+
+EXTERN int asn1PE_H245UnicastAddress_iPXAddress_netnum (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_netnum* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPXAddress_netnum (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_netnum* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_tsapIdentifier                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPXAddress_tsapIdentifier {
+   ASN1UINT numocts;
+   ASN1OCTET data[2];
+} H245UnicastAddress_iPXAddress_tsapIdentifier;
+
+EXTERN int asn1PE_H245UnicastAddress_iPXAddress_tsapIdentifier (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_tsapIdentifier* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPXAddress_tsapIdentifier (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_tsapIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPXAddress {
+   H245UnicastAddress_iPXAddress_node node;
+   H245UnicastAddress_iPXAddress_netnum netnum;
+   H245UnicastAddress_iPXAddress_tsapIdentifier tsapIdentifier;
+} H245UnicastAddress_iPXAddress;
+
+EXTERN int asn1PE_H245UnicastAddress_iPXAddress (OOCTXT* pctxt, H245UnicastAddress_iPXAddress* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPXAddress (OOCTXT* pctxt, H245UnicastAddress_iPXAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iP6Address_network                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iP6Address_network {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H245UnicastAddress_iP6Address_network;
+
+EXTERN int asn1PE_H245UnicastAddress_iP6Address_network (OOCTXT* pctxt, H245UnicastAddress_iP6Address_network* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iP6Address_network (OOCTXT* pctxt, H245UnicastAddress_iP6Address_network* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iP6Address                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iP6Address {
+   H245UnicastAddress_iP6Address_network network;
+   ASN1USINT tsapIdentifier;
+} H245UnicastAddress_iP6Address;
+
+EXTERN int asn1PE_H245UnicastAddress_iP6Address (OOCTXT* pctxt, H245UnicastAddress_iP6Address* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iP6Address (OOCTXT* pctxt, H245UnicastAddress_iP6Address* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_netBios                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_netBios {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H245UnicastAddress_netBios;
+
+EXTERN int asn1PE_H245UnicastAddress_netBios (OOCTXT* pctxt, H245UnicastAddress_netBios* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_netBios (OOCTXT* pctxt, H245UnicastAddress_netBios* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_routing               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245UnicastAddress_iPSourceRouteAddress_routing_strict 1
+#define T_H245UnicastAddress_iPSourceRouteAddress_routing_loose 2
+
+typedef struct EXTERN H245UnicastAddress_iPSourceRouteAddress_routing {
+   int t;
+} H245UnicastAddress_iPSourceRouteAddress_routing;
+
+EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_routing (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_routing* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_routing (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_routing* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_network               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPSourceRouteAddress_network {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H245UnicastAddress_iPSourceRouteAddress_network;
+
+EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_network* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_network* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_route_element         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPSourceRouteAddress_route_element {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H245UnicastAddress_iPSourceRouteAddress_route_element;
+
+EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_route_element* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_route_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245UnicastAddress_iPSourceRouteAddress_route_elem  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element {
+   ASN1UINT n;
+   H245UnicastAddress_iPSourceRouteAddress_route_element *elem;
+} H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element;
+
+EXTERN int asn1PE_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_iPSourceRouteAddress {
+   H245UnicastAddress_iPSourceRouteAddress_routing routing;
+   H245UnicastAddress_iPSourceRouteAddress_network network;
+   ASN1USINT tsapIdentifier;
+   H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element route;
+} H245UnicastAddress_iPSourceRouteAddress;
+
+EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_nsap                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UnicastAddress_nsap {
+   ASN1UINT numocts;
+   ASN1OCTET data[20];
+} H245UnicastAddress_nsap;
+
+EXTERN int asn1PE_H245UnicastAddress_nsap (OOCTXT* pctxt, H245UnicastAddress_nsap* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress_nsap (OOCTXT* pctxt, H245UnicastAddress_nsap* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress                                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245UnicastAddress_iPAddress  1
+#define T_H245UnicastAddress_iPXAddress 2
+#define T_H245UnicastAddress_iP6Address 3
+#define T_H245UnicastAddress_netBios    4
+#define T_H245UnicastAddress_iPSourceRouteAddress 5
+#define T_H245UnicastAddress_nsap       6
+#define T_H245UnicastAddress_nonStandardAddress 7
+#define T_H245UnicastAddress_extElem1   8
+
+typedef struct EXTERN H245UnicastAddress {
+   int t;
+   union {
+      /* t = 1 */
+      H245UnicastAddress_iPAddress *iPAddress;
+      /* t = 2 */
+      H245UnicastAddress_iPXAddress *iPXAddress;
+      /* t = 3 */
+      H245UnicastAddress_iP6Address *iP6Address;
+      /* t = 4 */
+      H245UnicastAddress_netBios *netBios;
+      /* t = 5 */
+      H245UnicastAddress_iPSourceRouteAddress *iPSourceRouteAddress;
+      /* t = 6 */
+      H245UnicastAddress_nsap *nsap;
+      /* t = 7 */
+      H245NonStandardParameter *nonStandardAddress;
+      /* t = 8 */
+   } u;
+} H245UnicastAddress;
+
+EXTERN int asn1PE_H245UnicastAddress (OOCTXT* pctxt, H245UnicastAddress* pvalue);
+
+EXTERN int asn1PD_H245UnicastAddress (OOCTXT* pctxt, H245UnicastAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iPAddress_network                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MulticastAddress_iPAddress_network {
+   ASN1UINT numocts;
+   ASN1OCTET data[4];
+} H245MulticastAddress_iPAddress_network;
+
+EXTERN int asn1PE_H245MulticastAddress_iPAddress_network (OOCTXT* pctxt, H245MulticastAddress_iPAddress_network* pvalue);
+
+EXTERN int asn1PD_H245MulticastAddress_iPAddress_network (OOCTXT* pctxt, H245MulticastAddress_iPAddress_network* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iPAddress                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MulticastAddress_iPAddress {
+   H245MulticastAddress_iPAddress_network network;
+   ASN1USINT tsapIdentifier;
+} H245MulticastAddress_iPAddress;
+
+EXTERN int asn1PE_H245MulticastAddress_iPAddress (OOCTXT* pctxt, H245MulticastAddress_iPAddress* pvalue);
+
+EXTERN int asn1PD_H245MulticastAddress_iPAddress (OOCTXT* pctxt, H245MulticastAddress_iPAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iP6Address_network                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MulticastAddress_iP6Address_network {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H245MulticastAddress_iP6Address_network;
+
+EXTERN int asn1PE_H245MulticastAddress_iP6Address_network (OOCTXT* pctxt, H245MulticastAddress_iP6Address_network* pvalue);
+
+EXTERN int asn1PD_H245MulticastAddress_iP6Address_network (OOCTXT* pctxt, H245MulticastAddress_iP6Address_network* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iP6Address                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MulticastAddress_iP6Address {
+   H245MulticastAddress_iP6Address_network network;
+   ASN1USINT tsapIdentifier;
+} H245MulticastAddress_iP6Address;
+
+EXTERN int asn1PE_H245MulticastAddress_iP6Address (OOCTXT* pctxt, H245MulticastAddress_iP6Address* pvalue);
+
+EXTERN int asn1PD_H245MulticastAddress_iP6Address (OOCTXT* pctxt, H245MulticastAddress_iP6Address* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_nsap                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MulticastAddress_nsap {
+   ASN1UINT numocts;
+   ASN1OCTET data[20];
+} H245MulticastAddress_nsap;
+
+EXTERN int asn1PE_H245MulticastAddress_nsap (OOCTXT* pctxt, H245MulticastAddress_nsap* pvalue);
+
+EXTERN int asn1PD_H245MulticastAddress_nsap (OOCTXT* pctxt, H245MulticastAddress_nsap* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MulticastAddress_iPAddress 1
+#define T_H245MulticastAddress_iP6Address 2
+#define T_H245MulticastAddress_nsap     3
+#define T_H245MulticastAddress_nonStandardAddress 4
+#define T_H245MulticastAddress_extElem1 5
+
+typedef struct EXTERN H245MulticastAddress {
+   int t;
+   union {
+      /* t = 1 */
+      H245MulticastAddress_iPAddress *iPAddress;
+      /* t = 2 */
+      H245MulticastAddress_iP6Address *iP6Address;
+      /* t = 3 */
+      H245MulticastAddress_nsap *nsap;
+      /* t = 4 */
+      H245NonStandardParameter *nonStandardAddress;
+      /* t = 5 */
+   } u;
+} H245MulticastAddress;
+
+EXTERN int asn1PE_H245MulticastAddress (OOCTXT* pctxt, H245MulticastAddress* pvalue);
+
+EXTERN int asn1PD_H245MulticastAddress (OOCTXT* pctxt, H245MulticastAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245TransportAddress_unicastAddress 1
+#define T_H245TransportAddress_multicastAddress 2
+#define T_H245TransportAddress_extElem1 3
+
+typedef struct EXTERN H245TransportAddress {
+   int t;
+   union {
+      /* t = 1 */
+      H245UnicastAddress *unicastAddress;
+      /* t = 2 */
+      H245MulticastAddress *multicastAddress;
+      /* t = 3 */
+   } u;
+} H245TransportAddress;
+
+EXTERN int asn1PE_H245TransportAddress (OOCTXT* pctxt, H245TransportAddress* pvalue);
+
+EXTERN int asn1PD_H245TransportAddress (OOCTXT* pctxt, H245TransportAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  McuNumber                                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT8 H245McuNumber;
+
+EXTERN int asn1PE_H245McuNumber (OOCTXT* pctxt, H245McuNumber value);
+
+EXTERN int asn1PD_H245McuNumber (OOCTXT* pctxt, H245McuNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalNumber                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT8 H245TerminalNumber;
+
+EXTERN int asn1PE_H245TerminalNumber (OOCTXT* pctxt, H245TerminalNumber value);
+
+EXTERN int asn1PD_H245TerminalNumber (OOCTXT* pctxt, H245TerminalNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalLabel                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TerminalLabel {
+   H245McuNumber mcuNumber;
+   H245TerminalNumber terminalNumber;
+} H245TerminalLabel;
+
+EXTERN int asn1PE_H245TerminalLabel (OOCTXT* pctxt, H245TerminalLabel* pvalue);
+
+EXTERN int asn1PD_H245TerminalLabel (OOCTXT* pctxt, H245TerminalLabel* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelParameters_mediaPacketization          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H2250LogicalChannelParameters_mediaPacketization_h261aVideoPacketization 1
+#define T_H245H2250LogicalChannelParameters_mediaPacketization_rtpPayloadType 2
+#define T_H245H2250LogicalChannelParameters_mediaPacketization_extElem1 3
+
+typedef struct EXTERN H245H2250LogicalChannelParameters_mediaPacketization {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245RTPPayloadType *rtpPayloadType;
+      /* t = 3 */
+   } u;
+} H245H2250LogicalChannelParameters_mediaPacketization;
+
+EXTERN int asn1PE_H245H2250LogicalChannelParameters_mediaPacketization (OOCTXT* pctxt, H245H2250LogicalChannelParameters_mediaPacketization* pvalue);
+
+EXTERN int asn1PD_H245H2250LogicalChannelParameters_mediaPacketization (OOCTXT* pctxt, H245H2250LogicalChannelParameters_mediaPacketization* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelParameters                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H2250LogicalChannelParameters {
+   struct {
+      unsigned nonStandardPresent : 1;
+      unsigned associatedSessionIDPresent : 1;
+      unsigned mediaChannelPresent : 1;
+      unsigned mediaGuaranteedDeliveryPresent : 1;
+      unsigned mediaControlChannelPresent : 1;
+      unsigned mediaControlGuaranteedDeliveryPresent : 1;
+      unsigned silenceSuppressionPresent : 1;
+      unsigned destinationPresent : 1;
+      unsigned dynamicRTPPayloadTypePresent : 1;
+      unsigned mediaPacketizationPresent : 1;
+      unsigned transportCapabilityPresent : 1;
+      unsigned redundancyEncodingPresent : 1;
+      unsigned sourcePresent : 1;
+   } m;
+   H245_SeqOfH245NonStandardParameter nonStandard;
+   ASN1UINT8 sessionID;
+   ASN1UINT8 associatedSessionID;
+   H245TransportAddress mediaChannel;
+   ASN1BOOL mediaGuaranteedDelivery;
+   H245TransportAddress mediaControlChannel;
+   ASN1BOOL mediaControlGuaranteedDelivery;
+   ASN1BOOL silenceSuppression;
+   H245TerminalLabel destination;
+   ASN1UINT8 dynamicRTPPayloadType;
+   H245H2250LogicalChannelParameters_mediaPacketization mediaPacketization;
+   H245TransportCapability transportCapability;
+   H245RedundancyEncoding redundancyEncoding;
+   H245TerminalLabel source;
+} H245H2250LogicalChannelParameters;
+
+EXTERN int asn1PE_H245H2250LogicalChannelParameters (OOCTXT* pctxt, H245H2250LogicalChannelParameters* pvalue);
+
+EXTERN int asn1PD_H245H2250LogicalChannelParameters (OOCTXT* pctxt, H245H2250LogicalChannelParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_forwardLogicalChannelParameters_multi  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h222LogicalChannelParameters 1
+#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h223LogicalChannelParameters 2
+#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_v76LogicalChannelParameters 3
+#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters 4
+#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_none 5
+#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_extElem1 6
+
+typedef struct EXTERN H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters {
+   int t;
+   union {
+      /* t = 1 */
+      H245H222LogicalChannelParameters *h222LogicalChannelParameters;
+      /* t = 2 */
+      H245H223LogicalChannelParameters *h223LogicalChannelParameters;
+      /* t = 3 */
+      H245V76LogicalChannelParameters *v76LogicalChannelParameters;
+      /* t = 4 */
+      H245H2250LogicalChannelParameters *h2250LogicalChannelParameters;
+      /* t = 5 */
+      /* t = 6 */
+   } u;
+} H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters;
+
+EXTERN int asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_forwardLogicalChannelParameters        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245OpenLogicalChannel_forwardLogicalChannelParameters {
+   struct {
+      unsigned portNumberPresent : 1;
+      unsigned forwardLogicalChannelDependencyPresent : 1;
+      unsigned replacementForPresent : 1;
+   } m;
+   ASN1USINT portNumber;
+   H245DataType dataType;
+   H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters multiplexParameters;
+   H245LogicalChannelNumber forwardLogicalChannelDependency;
+   H245LogicalChannelNumber replacementFor;
+} H245OpenLogicalChannel_forwardLogicalChannelParameters;
+
+EXTERN int asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_reverseLogicalChannelParameters_multi  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h223LogicalChannelParameters 1
+#define T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_v76LogicalChannelParameters 2
+#define T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters 3
+#define T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_extElem1 4
+
+typedef struct EXTERN H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters {
+   int t;
+   union {
+      /* t = 1 */
+      H245H223LogicalChannelParameters *h223LogicalChannelParameters;
+      /* t = 2 */
+      H245V76LogicalChannelParameters *v76LogicalChannelParameters;
+      /* t = 3 */
+      H245H2250LogicalChannelParameters *h2250LogicalChannelParameters;
+      /* t = 4 */
+   } u;
+} H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters;
+
+EXTERN int asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_reverseLogicalChannelParameters        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245OpenLogicalChannel_reverseLogicalChannelParameters {
+   struct {
+      unsigned multiplexParametersPresent : 1;
+      unsigned reverseLogicalChannelDependencyPresent : 1;
+      unsigned replacementForPresent : 1;
+   } m;
+   H245DataType dataType;
+   H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters multiplexParameters;
+   H245LogicalChannelNumber reverseLogicalChannelDependency;
+   H245LogicalChannelNumber replacementFor;
+} H245OpenLogicalChannel_reverseLogicalChannelParameters;
+
+EXTERN int asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_distribution                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NetworkAccessParameters_distribution_unicast 1
+#define T_H245NetworkAccessParameters_distribution_multicast 2
+#define T_H245NetworkAccessParameters_distribution_extElem1 3
+
+typedef struct EXTERN H245NetworkAccessParameters_distribution {
+   int t;
+} H245NetworkAccessParameters_distribution;
+
+EXTERN int asn1PE_H245NetworkAccessParameters_distribution (OOCTXT* pctxt, H245NetworkAccessParameters_distribution* pvalue);
+
+EXTERN int asn1PD_H245NetworkAccessParameters_distribution (OOCTXT* pctxt, H245NetworkAccessParameters_distribution* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_networkAddress                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NetworkAccessParameters_networkAddress_q2931Address 1
+#define T_H245NetworkAccessParameters_networkAddress_e164Address 2
+#define T_H245NetworkAccessParameters_networkAddress_localAreaAddress 3
+#define T_H245NetworkAccessParameters_networkAddress_extElem1 4
+
+typedef struct EXTERN H245NetworkAccessParameters_networkAddress {
+   int t;
+   union {
+      /* t = 1 */
+      H245Q2931Address *q2931Address;
+      /* t = 2 */
+      ASN1IA5String e164Address;
+      /* t = 3 */
+      H245TransportAddress *localAreaAddress;
+      /* t = 4 */
+   } u;
+} H245NetworkAccessParameters_networkAddress;
+
+EXTERN int asn1PE_H245NetworkAccessParameters_networkAddress (OOCTXT* pctxt, H245NetworkAccessParameters_networkAddress* pvalue);
+
+EXTERN int asn1PD_H245NetworkAccessParameters_networkAddress (OOCTXT* pctxt, H245NetworkAccessParameters_networkAddress* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_externalReference                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NetworkAccessParameters_externalReference {
+   ASN1UINT numocts;
+   ASN1OCTET data[255];
+} H245NetworkAccessParameters_externalReference;
+
+EXTERN int asn1PE_H245NetworkAccessParameters_externalReference (OOCTXT* pctxt, H245NetworkAccessParameters_externalReference* pvalue);
+
+EXTERN int asn1PD_H245NetworkAccessParameters_externalReference (OOCTXT* pctxt, H245NetworkAccessParameters_externalReference* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_t120SetupProcedure                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NetworkAccessParameters_t120SetupProcedure_originateCall 1
+#define T_H245NetworkAccessParameters_t120SetupProcedure_waitForCall 2
+#define T_H245NetworkAccessParameters_t120SetupProcedure_issueQuery 3
+#define T_H245NetworkAccessParameters_t120SetupProcedure_extElem1 4
+
+typedef struct EXTERN H245NetworkAccessParameters_t120SetupProcedure {
+   int t;
+} H245NetworkAccessParameters_t120SetupProcedure;
+
+EXTERN int asn1PE_H245NetworkAccessParameters_t120SetupProcedure (OOCTXT* pctxt, H245NetworkAccessParameters_t120SetupProcedure* pvalue);
+
+EXTERN int asn1PD_H245NetworkAccessParameters_t120SetupProcedure (OOCTXT* pctxt, H245NetworkAccessParameters_t120SetupProcedure* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NetworkAccessParameters {
+   struct {
+      unsigned distributionPresent : 1;
+      unsigned externalReferencePresent : 1;
+      unsigned t120SetupProcedurePresent : 1;
+   } m;
+   H245NetworkAccessParameters_distribution distribution;
+   H245NetworkAccessParameters_networkAddress networkAddress;
+   ASN1BOOL associateConference;
+   H245NetworkAccessParameters_externalReference externalReference;
+   H245NetworkAccessParameters_t120SetupProcedure t120SetupProcedure;
+} H245NetworkAccessParameters;
+
+EXTERN int asn1PE_H245NetworkAccessParameters (OOCTXT* pctxt, H245NetworkAccessParameters* pvalue);
+
+EXTERN int asn1PD_H245NetworkAccessParameters (OOCTXT* pctxt, H245NetworkAccessParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EscrowData_escrowValue                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245EscrowData_escrowValue {
+   ASN1UINT  numbits;
+   ASN1OCTET data[8192];
+} H245EscrowData_escrowValue;
+
+EXTERN int asn1PE_H245EscrowData_escrowValue (OOCTXT* pctxt, H245EscrowData_escrowValue* pvalue);
+
+EXTERN int asn1PD_H245EscrowData_escrowValue (OOCTXT* pctxt, H245EscrowData_escrowValue* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EscrowData                                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245EscrowData {
+   ASN1OBJID escrowID;
+   H245EscrowData_escrowValue escrowValue;
+} H245EscrowData;
+
+EXTERN int asn1PE_H245EscrowData (OOCTXT* pctxt, H245EscrowData* pvalue);
+
+EXTERN int asn1PD_H245EscrowData (OOCTXT* pctxt, H245EscrowData* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionSync_escrowentry                                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245EscrowData */
+typedef DList H245EncryptionSync_escrowentry;
+
+EXTERN int asn1PE_H245EncryptionSync_escrowentry (OOCTXT* pctxt, H245EncryptionSync_escrowentry* pvalue);
+
+EXTERN int asn1PD_H245EncryptionSync_escrowentry (OOCTXT* pctxt, H245EncryptionSync_escrowentry* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionSync                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245EncryptionSync {
+   struct {
+      unsigned nonStandardPresent : 1;
+      unsigned escrowentryPresent : 1;
+   } m;
+   H245NonStandardParameter nonStandard;
+   ASN1UINT8 synchFlag;
+   ASN1DynOctStr h235Key;
+   H245EncryptionSync_escrowentry escrowentry;
+} H245EncryptionSync;
+
+EXTERN int asn1PE_H245EncryptionSync (OOCTXT* pctxt, H245EncryptionSync* pvalue);
+
+EXTERN int asn1PD_H245EncryptionSync (OOCTXT* pctxt, H245EncryptionSync* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245OpenLogicalChannel {
+   struct {
+      unsigned reverseLogicalChannelParametersPresent : 1;
+      unsigned separateStackPresent : 1;
+      unsigned encryptionSyncPresent : 1;
+   } m;
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+   H245OpenLogicalChannel_forwardLogicalChannelParameters forwardLogicalChannelParameters;
+   H245OpenLogicalChannel_reverseLogicalChannelParameters reverseLogicalChannelParameters;
+   H245NetworkAccessParameters separateStack;
+   H245EncryptionSync encryptionSync;
+} H245OpenLogicalChannel;
+
+EXTERN int asn1PE_H245OpenLogicalChannel (OOCTXT* pctxt, H245OpenLogicalChannel* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannel (OOCTXT* pctxt, H245OpenLogicalChannel* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel_source                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CloseLogicalChannel_source_user 1
+#define T_H245CloseLogicalChannel_source_lcse 2
+
+typedef struct EXTERN H245CloseLogicalChannel_source {
+   int t;
+} H245CloseLogicalChannel_source;
+
+EXTERN int asn1PE_H245CloseLogicalChannel_source (OOCTXT* pctxt, H245CloseLogicalChannel_source* pvalue);
+
+EXTERN int asn1PD_H245CloseLogicalChannel_source (OOCTXT* pctxt, H245CloseLogicalChannel_source* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel_reason                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CloseLogicalChannel_reason_unknown 1
+#define T_H245CloseLogicalChannel_reason_reopen 2
+#define T_H245CloseLogicalChannel_reason_reservationFailure 3
+#define T_H245CloseLogicalChannel_reason_extElem1 4
+
+typedef struct EXTERN H245CloseLogicalChannel_reason {
+   int t;
+} H245CloseLogicalChannel_reason;
+
+EXTERN int asn1PE_H245CloseLogicalChannel_reason (OOCTXT* pctxt, H245CloseLogicalChannel_reason* pvalue);
+
+EXTERN int asn1PD_H245CloseLogicalChannel_reason (OOCTXT* pctxt, H245CloseLogicalChannel_reason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CloseLogicalChannel {
+   struct {
+      unsigned reasonPresent : 1;
+   } m;
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+   H245CloseLogicalChannel_source source;
+   H245CloseLogicalChannel_reason reason;
+} H245CloseLogicalChannel;
+
+EXTERN int asn1PE_H245CloseLogicalChannel (OOCTXT* pctxt, H245CloseLogicalChannel* pvalue);
+
+EXTERN int asn1PD_H245CloseLogicalChannel (OOCTXT* pctxt, H245CloseLogicalChannel* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelClose_reason                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RequestChannelClose_reason_unknown 1
+#define T_H245RequestChannelClose_reason_normal 2
+#define T_H245RequestChannelClose_reason_reopen 3
+#define T_H245RequestChannelClose_reason_reservationFailure 4
+#define T_H245RequestChannelClose_reason_extElem1 5
+
+typedef struct EXTERN H245RequestChannelClose_reason {
+   int t;
+} H245RequestChannelClose_reason;
+
+EXTERN int asn1PE_H245RequestChannelClose_reason (OOCTXT* pctxt, H245RequestChannelClose_reason* pvalue);
+
+EXTERN int asn1PD_H245RequestChannelClose_reason (OOCTXT* pctxt, H245RequestChannelClose_reason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelClose                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestChannelClose {
+   struct {
+      unsigned qosCapabilityPresent : 1;
+      unsigned reasonPresent : 1;
+   } m;
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+   H245QOSCapability qosCapability;
+   H245RequestChannelClose_reason reason;
+} H245RequestChannelClose;
+
+EXTERN int asn1PE_H245RequestChannelClose (OOCTXT* pctxt, H245RequestChannelClose* pvalue);
+
+EXTERN int asn1PD_H245RequestChannelClose (OOCTXT* pctxt, H245RequestChannelClose* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexTableEntryNumber                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT8 H245MultiplexTableEntryNumber;
+
+EXTERN int asn1PE_H245MultiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexTableEntryNumber value);
+
+EXTERN int asn1PD_H245MultiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexTableEntryNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_type_subElementList                      */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MultiplexElement */
+typedef DList H245MultiplexElement_type_subElementList;
+
+EXTERN int asn1PE_H245MultiplexElement_type_subElementList (OOCTXT* pctxt, H245MultiplexElement_type_subElementList* pvalue);
+
+EXTERN int asn1PD_H245MultiplexElement_type_subElementList (OOCTXT* pctxt, H245MultiplexElement_type_subElementList* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_type                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultiplexElement_type_logicalChannelNumber 1
+#define T_H245MultiplexElement_type_subElementList 2
+
+typedef struct EXTERN H245MultiplexElement_type {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1USINT logicalChannelNumber;
+      /* t = 2 */
+      H245MultiplexElement_type_subElementList *subElementList;
+   } u;
+} H245MultiplexElement_type;
+
+EXTERN int asn1PE_H245MultiplexElement_type (OOCTXT* pctxt, H245MultiplexElement_type* pvalue);
+
+EXTERN int asn1PD_H245MultiplexElement_type (OOCTXT* pctxt, H245MultiplexElement_type* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_repeatCount                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultiplexElement_repeatCount_finite 1
+#define T_H245MultiplexElement_repeatCount_untilClosingFlag 2
+
+typedef struct EXTERN H245MultiplexElement_repeatCount {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1USINT finite;
+      /* t = 2 */
+   } u;
+} H245MultiplexElement_repeatCount;
+
+EXTERN int asn1PE_H245MultiplexElement_repeatCount (OOCTXT* pctxt, H245MultiplexElement_repeatCount* pvalue);
+
+EXTERN int asn1PD_H245MultiplexElement_repeatCount (OOCTXT* pctxt, H245MultiplexElement_repeatCount* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexElement {
+   H245MultiplexElement_type type;
+   H245MultiplexElement_repeatCount repeatCount;
+} H245MultiplexElement;
+
+EXTERN int asn1PE_H245MultiplexElement (OOCTXT* pctxt, H245MultiplexElement* pvalue);
+
+EXTERN int asn1PD_H245MultiplexElement (OOCTXT* pctxt, H245MultiplexElement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryDescriptor_elementList                      */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MultiplexElement */
+typedef DList H245MultiplexEntryDescriptor_elementList;
+
+EXTERN int asn1PE_H245MultiplexEntryDescriptor_elementList (OOCTXT* pctxt, H245MultiplexEntryDescriptor_elementList* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntryDescriptor_elementList (OOCTXT* pctxt, H245MultiplexEntryDescriptor_elementList* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryDescriptor                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexEntryDescriptor {
+   struct {
+      unsigned elementListPresent : 1;
+   } m;
+   H245MultiplexTableEntryNumber multiplexTableEntryNumber;
+   H245MultiplexEntryDescriptor_elementList elementList;
+} H245MultiplexEntryDescriptor;
+
+EXTERN int asn1PE_H245MultiplexEntryDescriptor (OOCTXT* pctxt, H245MultiplexEntryDescriptor* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntryDescriptor (OOCTXT* pctxt, H245MultiplexEntryDescriptor* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySend_multiplexEntryDescriptors              */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MultiplexEntryDescriptor */
+typedef DList H245MultiplexEntrySend_multiplexEntryDescriptors;
+
+EXTERN int asn1PE_H245MultiplexEntrySend_multiplexEntryDescriptors (OOCTXT* pctxt, H245MultiplexEntrySend_multiplexEntryDescriptors* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntrySend_multiplexEntryDescriptors (OOCTXT* pctxt, H245MultiplexEntrySend_multiplexEntryDescriptors* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySend                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexEntrySend {
+   H245SequenceNumber sequenceNumber;
+   H245MultiplexEntrySend_multiplexEntryDescriptors multiplexEntryDescriptors;
+} H245MultiplexEntrySend;
+
+EXTERN int asn1PE_H245MultiplexEntrySend (OOCTXT* pctxt, H245MultiplexEntrySend* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntrySend (OOCTXT* pctxt, H245MultiplexEntrySend* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntry_entryNumbers                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntry_entryNumbers {
+   ASN1UINT n;
+   H245MultiplexTableEntryNumber elem[15];
+} H245RequestMultiplexEntry_entryNumbers;
+
+EXTERN int asn1PE_H245RequestMultiplexEntry_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntry_entryNumbers* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntry_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntry_entryNumbers* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntry                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntry {
+   H245RequestMultiplexEntry_entryNumbers entryNumbers;
+} H245RequestMultiplexEntry;
+
+EXTERN int asn1PE_H245RequestMultiplexEntry (OOCTXT* pctxt, H245RequestMultiplexEntry* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntry (OOCTXT* pctxt, H245RequestMultiplexEntry* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoMode_resolution                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H261VideoMode_resolution_qcif 1
+#define T_H245H261VideoMode_resolution_cif 2
+
+typedef struct EXTERN H245H261VideoMode_resolution {
+   int t;
+} H245H261VideoMode_resolution;
+
+EXTERN int asn1PE_H245H261VideoMode_resolution (OOCTXT* pctxt, H245H261VideoMode_resolution* pvalue);
+
+EXTERN int asn1PD_H245H261VideoMode_resolution (OOCTXT* pctxt, H245H261VideoMode_resolution* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H261VideoMode {
+   H245H261VideoMode_resolution resolution;
+   ASN1USINT bitRate;
+   ASN1BOOL stillImageTransmission;
+} H245H261VideoMode;
+
+EXTERN int asn1PE_H245H261VideoMode (OOCTXT* pctxt, H245H261VideoMode* pvalue);
+
+EXTERN int asn1PD_H245H261VideoMode (OOCTXT* pctxt, H245H261VideoMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoMode_profileAndLevel                             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_SPatML 1
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_MPatLL 2
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_MPatML 3
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_MPatH_14 4
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_MPatHL 5
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_SNRatLL 6
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_SNRatML 7
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_SpatialatH_14 8
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_HPatML 9
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_HPatH_14 10
+#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_HPatHL 11
+#define T_H245H262VideoMode_profileAndLevel_extElem1 12
+
+typedef struct EXTERN H245H262VideoMode_profileAndLevel {
+   int t;
+} H245H262VideoMode_profileAndLevel;
+
+EXTERN int asn1PE_H245H262VideoMode_profileAndLevel (OOCTXT* pctxt, H245H262VideoMode_profileAndLevel* pvalue);
+
+EXTERN int asn1PD_H245H262VideoMode_profileAndLevel (OOCTXT* pctxt, H245H262VideoMode_profileAndLevel* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H262VideoMode {
+   struct {
+      unsigned videoBitRatePresent : 1;
+      unsigned vbvBufferSizePresent : 1;
+      unsigned samplesPerLinePresent : 1;
+      unsigned linesPerFramePresent : 1;
+      unsigned framesPerSecondPresent : 1;
+      unsigned luminanceSampleRatePresent : 1;
+   } m;
+   H245H262VideoMode_profileAndLevel profileAndLevel;
+   ASN1UINT videoBitRate;
+   ASN1UINT vbvBufferSize;
+   ASN1USINT samplesPerLine;
+   ASN1USINT linesPerFrame;
+   ASN1UINT8 framesPerSecond;
+   ASN1UINT luminanceSampleRate;
+} H245H262VideoMode;
+
+EXTERN int asn1PE_H245H262VideoMode (OOCTXT* pctxt, H245H262VideoMode* pvalue);
+
+EXTERN int asn1PD_H245H262VideoMode (OOCTXT* pctxt, H245H262VideoMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoMode_resolution                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H263VideoMode_resolution_sqcif 1
+#define T_H245H263VideoMode_resolution_qcif 2
+#define T_H245H263VideoMode_resolution_cif 3
+#define T_H245H263VideoMode_resolution_cif4 4
+#define T_H245H263VideoMode_resolution_cif16 5
+#define T_H245H263VideoMode_resolution_custom 6
+#define T_H245H263VideoMode_resolution_extElem1 7
+
+typedef struct EXTERN H245H263VideoMode_resolution {
+   int t;
+} H245H263VideoMode_resolution;
+
+EXTERN int asn1PE_H245H263VideoMode_resolution (OOCTXT* pctxt, H245H263VideoMode_resolution* pvalue);
+
+EXTERN int asn1PD_H245H263VideoMode_resolution (OOCTXT* pctxt, H245H263VideoMode_resolution* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H263VideoMode {
+   struct {
+      unsigned errorCompensationPresent : 1;
+      unsigned enhancementLayerInfoPresent : 1;
+      unsigned h263OptionsPresent : 1;
+   } m;
+   H245H263VideoMode_resolution resolution;
+   ASN1USINT bitRate;
+   ASN1BOOL unrestrictedVector;
+   ASN1BOOL arithmeticCoding;
+   ASN1BOOL advancedPrediction;
+   ASN1BOOL pbFrames;
+   ASN1BOOL errorCompensation;
+   H245EnhancementLayerInfo enhancementLayerInfo;
+   H245H263Options h263Options;
+} H245H263VideoMode;
+
+EXTERN int asn1PE_H245H263VideoMode (OOCTXT* pctxt, H245H263VideoMode* pvalue);
+
+EXTERN int asn1PD_H245H263VideoMode (OOCTXT* pctxt, H245H263VideoMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172VideoMode                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245IS11172VideoMode {
+   struct {
+      unsigned videoBitRatePresent : 1;
+      unsigned vbvBufferSizePresent : 1;
+      unsigned samplesPerLinePresent : 1;
+      unsigned linesPerFramePresent : 1;
+      unsigned pictureRatePresent : 1;
+      unsigned luminanceSampleRatePresent : 1;
+   } m;
+   ASN1BOOL constrainedBitstream;
+   ASN1UINT videoBitRate;
+   ASN1UINT vbvBufferSize;
+   ASN1USINT samplesPerLine;
+   ASN1USINT linesPerFrame;
+   ASN1UINT8 pictureRate;
+   ASN1UINT luminanceSampleRate;
+} H245IS11172VideoMode;
+
+EXTERN int asn1PE_H245IS11172VideoMode (OOCTXT* pctxt, H245IS11172VideoMode* pvalue);
+
+EXTERN int asn1PD_H245IS11172VideoMode (OOCTXT* pctxt, H245IS11172VideoMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VideoMode                                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245VideoMode_nonStandard     1
+#define T_H245VideoMode_h261VideoMode   2
+#define T_H245VideoMode_h262VideoMode   3
+#define T_H245VideoMode_h263VideoMode   4
+#define T_H245VideoMode_is11172VideoMode 5
+#define T_H245VideoMode_genericVideoMode 6
+#define T_H245VideoMode_extElem1        7
+
+typedef struct EXTERN H245VideoMode {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245H261VideoMode *h261VideoMode;
+      /* t = 3 */
+      H245H262VideoMode *h262VideoMode;
+      /* t = 4 */
+      H245H263VideoMode *h263VideoMode;
+      /* t = 5 */
+      H245IS11172VideoMode *is11172VideoMode;
+      /* t = 6 */
+      H245GenericCapability *genericVideoMode;
+      /* t = 7 */
+   } u;
+} H245VideoMode;
+
+EXTERN int asn1PE_H245VideoMode (OOCTXT* pctxt, H245VideoMode* pvalue);
+
+EXTERN int asn1PD_H245VideoMode (OOCTXT* pctxt, H245VideoMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AudioMode_g7231                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245AudioMode_g7231_noSilenceSuppressionLowRate 1
+#define T_H245AudioMode_g7231_noSilenceSuppressionHighRate 2
+#define T_H245AudioMode_g7231_silenceSuppressionLowRate 3
+#define T_H245AudioMode_g7231_silenceSuppressionHighRate 4
+
+typedef struct EXTERN H245AudioMode_g7231 {
+   int t;
+} H245AudioMode_g7231;
+
+EXTERN int asn1PE_H245AudioMode_g7231 (OOCTXT* pctxt, H245AudioMode_g7231* pvalue);
+
+EXTERN int asn1PD_H245AudioMode_g7231 (OOCTXT* pctxt, H245AudioMode_g7231* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_audioLayer                               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245IS11172AudioMode_audioLayer_audioLayer1 1
+#define T_H245IS11172AudioMode_audioLayer_audioLayer2 2
+#define T_H245IS11172AudioMode_audioLayer_audioLayer3 3
+
+typedef struct EXTERN H245IS11172AudioMode_audioLayer {
+   int t;
+} H245IS11172AudioMode_audioLayer;
+
+EXTERN int asn1PE_H245IS11172AudioMode_audioLayer (OOCTXT* pctxt, H245IS11172AudioMode_audioLayer* pvalue);
+
+EXTERN int asn1PD_H245IS11172AudioMode_audioLayer (OOCTXT* pctxt, H245IS11172AudioMode_audioLayer* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_audioSampling                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245IS11172AudioMode_audioSampling_audioSampling32k 1
+#define T_H245IS11172AudioMode_audioSampling_audioSampling44k1 2
+#define T_H245IS11172AudioMode_audioSampling_audioSampling48k 3
+
+typedef struct EXTERN H245IS11172AudioMode_audioSampling {
+   int t;
+} H245IS11172AudioMode_audioSampling;
+
+EXTERN int asn1PE_H245IS11172AudioMode_audioSampling (OOCTXT* pctxt, H245IS11172AudioMode_audioSampling* pvalue);
+
+EXTERN int asn1PD_H245IS11172AudioMode_audioSampling (OOCTXT* pctxt, H245IS11172AudioMode_audioSampling* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_multichannelType                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245IS11172AudioMode_multichannelType_singleChannel 1
+#define T_H245IS11172AudioMode_multichannelType_twoChannelStereo 2
+#define T_H245IS11172AudioMode_multichannelType_twoChannelDual 3
+
+typedef struct EXTERN H245IS11172AudioMode_multichannelType {
+   int t;
+} H245IS11172AudioMode_multichannelType;
+
+EXTERN int asn1PE_H245IS11172AudioMode_multichannelType (OOCTXT* pctxt, H245IS11172AudioMode_multichannelType* pvalue);
+
+EXTERN int asn1PD_H245IS11172AudioMode_multichannelType (OOCTXT* pctxt, H245IS11172AudioMode_multichannelType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245IS11172AudioMode {
+   H245IS11172AudioMode_audioLayer audioLayer;
+   H245IS11172AudioMode_audioSampling audioSampling;
+   H245IS11172AudioMode_multichannelType multichannelType;
+   ASN1USINT bitRate;
+} H245IS11172AudioMode;
+
+EXTERN int asn1PE_H245IS11172AudioMode (OOCTXT* pctxt, H245IS11172AudioMode* pvalue);
+
+EXTERN int asn1PD_H245IS11172AudioMode (OOCTXT* pctxt, H245IS11172AudioMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_audioLayer                               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245IS13818AudioMode_audioLayer_audioLayer1 1
+#define T_H245IS13818AudioMode_audioLayer_audioLayer2 2
+#define T_H245IS13818AudioMode_audioLayer_audioLayer3 3
+
+typedef struct EXTERN H245IS13818AudioMode_audioLayer {
+   int t;
+} H245IS13818AudioMode_audioLayer;
+
+EXTERN int asn1PE_H245IS13818AudioMode_audioLayer (OOCTXT* pctxt, H245IS13818AudioMode_audioLayer* pvalue);
+
+EXTERN int asn1PD_H245IS13818AudioMode_audioLayer (OOCTXT* pctxt, H245IS13818AudioMode_audioLayer* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_audioSampling                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245IS13818AudioMode_audioSampling_audioSampling16k 1
+#define T_H245IS13818AudioMode_audioSampling_audioSampling22k05 2
+#define T_H245IS13818AudioMode_audioSampling_audioSampling24k 3
+#define T_H245IS13818AudioMode_audioSampling_audioSampling32k 4
+#define T_H245IS13818AudioMode_audioSampling_audioSampling44k1 5
+#define T_H245IS13818AudioMode_audioSampling_audioSampling48k 6
+
+typedef struct EXTERN H245IS13818AudioMode_audioSampling {
+   int t;
+} H245IS13818AudioMode_audioSampling;
+
+EXTERN int asn1PE_H245IS13818AudioMode_audioSampling (OOCTXT* pctxt, H245IS13818AudioMode_audioSampling* pvalue);
+
+EXTERN int asn1PD_H245IS13818AudioMode_audioSampling (OOCTXT* pctxt, H245IS13818AudioMode_audioSampling* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_multichannelType                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245IS13818AudioMode_multichannelType_singleChannel 1
+#define T_H245IS13818AudioMode_multichannelType_twoChannelStereo 2
+#define T_H245IS13818AudioMode_multichannelType_twoChannelDual 3
+#define T_H245IS13818AudioMode_multichannelType_threeChannels2_1 4
+#define T_H245IS13818AudioMode_multichannelType_threeChannels3_0 5
+#define T_H245IS13818AudioMode_multichannelType_fourChannels2_0_2_0 6
+#define T_H245IS13818AudioMode_multichannelType_fourChannels2_2 7
+#define T_H245IS13818AudioMode_multichannelType_fourChannels3_1 8
+#define T_H245IS13818AudioMode_multichannelType_fiveChannels3_0_2_0 9
+#define T_H245IS13818AudioMode_multichannelType_fiveChannels3_2 10
+
+typedef struct EXTERN H245IS13818AudioMode_multichannelType {
+   int t;
+} H245IS13818AudioMode_multichannelType;
+
+EXTERN int asn1PE_H245IS13818AudioMode_multichannelType (OOCTXT* pctxt, H245IS13818AudioMode_multichannelType* pvalue);
+
+EXTERN int asn1PD_H245IS13818AudioMode_multichannelType (OOCTXT* pctxt, H245IS13818AudioMode_multichannelType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245IS13818AudioMode {
+   H245IS13818AudioMode_audioLayer audioLayer;
+   H245IS13818AudioMode_audioSampling audioSampling;
+   H245IS13818AudioMode_multichannelType multichannelType;
+   ASN1BOOL lowFrequencyEnhancement;
+   ASN1BOOL multilingual;
+   ASN1USINT bitRate;
+} H245IS13818AudioMode;
+
+EXTERN int asn1PE_H245IS13818AudioMode (OOCTXT* pctxt, H245IS13818AudioMode* pvalue);
+
+EXTERN int asn1PD_H245IS13818AudioMode (OOCTXT* pctxt, H245IS13818AudioMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCMode_g723AnnexCAudioMode                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245G7231AnnexCMode_g723AnnexCAudioMode {
+   ASN1UINT8 highRateMode0;
+   ASN1UINT8 highRateMode1;
+   ASN1UINT8 lowRateMode0;
+   ASN1UINT8 lowRateMode1;
+   ASN1UINT8 sidMode0;
+   ASN1UINT8 sidMode1;
+} H245G7231AnnexCMode_g723AnnexCAudioMode;
+
+EXTERN int asn1PE_H245G7231AnnexCMode_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCMode_g723AnnexCAudioMode* pvalue);
+
+EXTERN int asn1PD_H245G7231AnnexCMode_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCMode_g723AnnexCAudioMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCMode                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245G7231AnnexCMode {
+   ASN1USINT maxAl_sduAudioFrames;
+   ASN1BOOL silenceSuppression;
+   H245G7231AnnexCMode_g723AnnexCAudioMode g723AnnexCAudioMode;
+} H245G7231AnnexCMode;
+
+EXTERN int asn1PE_H245G7231AnnexCMode (OOCTXT* pctxt, H245G7231AnnexCMode* pvalue);
+
+EXTERN int asn1PD_H245G7231AnnexCMode (OOCTXT* pctxt, H245G7231AnnexCMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VBDMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VBDMode {
+   struct H245AudioMode *type;
+} H245VBDMode;
+
+EXTERN int asn1PE_H245VBDMode (OOCTXT* pctxt, H245VBDMode* pvalue);
+
+EXTERN int asn1PD_H245VBDMode (OOCTXT* pctxt, H245VBDMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  AudioMode                                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245AudioMode_nonStandard     1
+#define T_H245AudioMode_g711Alaw64k     2
+#define T_H245AudioMode_g711Alaw56k     3
+#define T_H245AudioMode_g711Ulaw64k     4
+#define T_H245AudioMode_g711Ulaw56k     5
+#define T_H245AudioMode_g722_64k        6
+#define T_H245AudioMode_g722_56k        7
+#define T_H245AudioMode_g722_48k        8
+#define T_H245AudioMode_g728            9
+#define T_H245AudioMode_g729            10
+#define T_H245AudioMode_g729AnnexA      11
+#define T_H245AudioMode_g7231           12
+#define T_H245AudioMode_is11172AudioMode 13
+#define T_H245AudioMode_is13818AudioMode 14
+#define T_H245AudioMode_g729wAnnexB     15
+#define T_H245AudioMode_g729AnnexAwAnnexB 16
+#define T_H245AudioMode_g7231AnnexCMode 17
+#define T_H245AudioMode_gsmFullRate     18
+#define T_H245AudioMode_gsmHalfRate     19
+#define T_H245AudioMode_gsmEnhancedFullRate 20
+#define T_H245AudioMode_genericAudioMode 21
+#define T_H245AudioMode_g729Extensions  22
+#define T_H245AudioMode_vbd             23
+#define T_H245AudioMode_extElem1        24
+
+typedef struct EXTERN H245AudioMode {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      /* t = 9 */
+      /* t = 10 */
+      /* t = 11 */
+      /* t = 12 */
+      H245AudioMode_g7231 *g7231;
+      /* t = 13 */
+      H245IS11172AudioMode *is11172AudioMode;
+      /* t = 14 */
+      H245IS13818AudioMode *is13818AudioMode;
+      /* t = 15 */
+      ASN1USINT g729wAnnexB;
+      /* t = 16 */
+      ASN1USINT g729AnnexAwAnnexB;
+      /* t = 17 */
+      H245G7231AnnexCMode *g7231AnnexCMode;
+      /* t = 18 */
+      H245GSMAudioCapability *gsmFullRate;
+      /* t = 19 */
+      H245GSMAudioCapability *gsmHalfRate;
+      /* t = 20 */
+      H245GSMAudioCapability *gsmEnhancedFullRate;
+      /* t = 21 */
+      H245GenericCapability *genericAudioMode;
+      /* t = 22 */
+      H245G729Extensions *g729Extensions;
+      /* t = 23 */
+      H245VBDMode *vbd;
+      /* t = 24 */
+   } u;
+} H245AudioMode;
+
+EXTERN int asn1PE_H245AudioMode (OOCTXT* pctxt, H245AudioMode* pvalue);
+
+EXTERN int asn1PD_H245AudioMode (OOCTXT* pctxt, H245AudioMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application_nlpid                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245DataMode_application_nlpid {
+   H245DataProtocolCapability nlpidProtocol;
+   ASN1DynOctStr nlpidData;
+} H245DataMode_application_nlpid;
+
+EXTERN int asn1PE_H245DataMode_application_nlpid (OOCTXT* pctxt, H245DataMode_application_nlpid* pvalue);
+
+EXTERN int asn1PD_H245DataMode_application_nlpid (OOCTXT* pctxt, H245DataMode_application_nlpid* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application_t38fax                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245DataMode_application_t38fax {
+   H245DataProtocolCapability t38FaxProtocol;
+   H245T38FaxProfile t38FaxProfile;
+} H245DataMode_application_t38fax;
+
+EXTERN int asn1PE_H245DataMode_application_t38fax (OOCTXT* pctxt, H245DataMode_application_t38fax* pvalue);
+
+EXTERN int asn1PD_H245DataMode_application_t38fax (OOCTXT* pctxt, H245DataMode_application_t38fax* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245DataMode_application_nonStandard 1
+#define T_H245DataMode_application_t120 2
+#define T_H245DataMode_application_dsm_cc 3
+#define T_H245DataMode_application_userData 4
+#define T_H245DataMode_application_t84  5
+#define T_H245DataMode_application_t434 6
+#define T_H245DataMode_application_h224 7
+#define T_H245DataMode_application_nlpid 8
+#define T_H245DataMode_application_dsvdControl 9
+#define T_H245DataMode_application_h222DataPartitioning 10
+#define T_H245DataMode_application_t30fax 11
+#define T_H245DataMode_application_t140 12
+#define T_H245DataMode_application_t38fax 13
+#define T_H245DataMode_application_genericDataMode 14
+#define T_H245DataMode_application_extElem1 15
+
+typedef struct EXTERN H245DataMode_application {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245DataProtocolCapability *t120;
+      /* t = 3 */
+      H245DataProtocolCapability *dsm_cc;
+      /* t = 4 */
+      H245DataProtocolCapability *userData;
+      /* t = 5 */
+      H245DataProtocolCapability *t84;
+      /* t = 6 */
+      H245DataProtocolCapability *t434;
+      /* t = 7 */
+      H245DataProtocolCapability *h224;
+      /* t = 8 */
+      H245DataMode_application_nlpid *nlpid;
+      /* t = 9 */
+      /* t = 10 */
+      H245DataProtocolCapability *h222DataPartitioning;
+      /* t = 11 */
+      H245DataProtocolCapability *t30fax;
+      /* t = 12 */
+      H245DataProtocolCapability *t140;
+      /* t = 13 */
+      H245DataMode_application_t38fax *t38fax;
+      /* t = 14 */
+      H245GenericCapability *genericDataMode;
+      /* t = 15 */
+   } u;
+} H245DataMode_application;
+
+EXTERN int asn1PE_H245DataMode_application (OOCTXT* pctxt, H245DataMode_application* pvalue);
+
+EXTERN int asn1PD_H245DataMode_application (OOCTXT* pctxt, H245DataMode_application* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245DataMode {
+   H245DataMode_application application;
+   ASN1UINT bitRate;
+} H245DataMode;
+
+EXTERN int asn1PE_H245DataMode (OOCTXT* pctxt, H245DataMode* pvalue);
+
+EXTERN int asn1PD_H245DataMode (OOCTXT* pctxt, H245DataMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H235Mode_mediaMode                                        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H235Mode_mediaMode_nonStandard 1
+#define T_H245H235Mode_mediaMode_videoMode 2
+#define T_H245H235Mode_mediaMode_audioMode 3
+#define T_H245H235Mode_mediaMode_dataMode 4
+#define T_H245H235Mode_mediaMode_extElem1 5
+
+typedef struct EXTERN H245H235Mode_mediaMode {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245VideoMode *videoMode;
+      /* t = 3 */
+      H245AudioMode *audioMode;
+      /* t = 4 */
+      H245DataMode *dataMode;
+      /* t = 5 */
+   } u;
+} H245H235Mode_mediaMode;
+
+EXTERN int asn1PE_H245H235Mode_mediaMode (OOCTXT* pctxt, H245H235Mode_mediaMode* pvalue);
+
+EXTERN int asn1PD_H245H235Mode_mediaMode (OOCTXT* pctxt, H245H235Mode_mediaMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H235Mode                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H235Mode {
+   H245EncryptionAuthenticationAndIntegrity encryptionAuthenticationAndIntegrity;
+   H245H235Mode_mediaMode mediaMode;
+} H245H235Mode;
+
+EXTERN int asn1PE_H245H235Mode (OOCTXT* pctxt, H245H235Mode* pvalue);
+
+EXTERN int asn1PD_H245H235Mode (OOCTXT* pctxt, H245H235Mode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTModeElement_type                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RedundancyEncodingDTModeElement_type_nonStandard 1
+#define T_H245RedundancyEncodingDTModeElement_type_videoMode 2
+#define T_H245RedundancyEncodingDTModeElement_type_audioMode 3
+#define T_H245RedundancyEncodingDTModeElement_type_dataMode 4
+#define T_H245RedundancyEncodingDTModeElement_type_encryptionMode 5
+#define T_H245RedundancyEncodingDTModeElement_type_h235Mode 6
+#define T_H245RedundancyEncodingDTModeElement_type_extElem1 7
+
+typedef struct EXTERN H245RedundancyEncodingDTModeElement_type {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245VideoMode *videoMode;
+      /* t = 3 */
+      H245AudioMode *audioMode;
+      /* t = 4 */
+      H245DataMode *dataMode;
+      /* t = 5 */
+      H245EncryptionMode *encryptionMode;
+      /* t = 6 */
+      H245H235Mode *h235Mode;
+      /* t = 7 */
+   } u;
+} H245RedundancyEncodingDTModeElement_type;
+
+EXTERN int asn1PE_H245RedundancyEncodingDTModeElement_type (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement_type* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingDTModeElement_type (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement_type* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTModeElement                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RedundancyEncodingDTModeElement {
+   H245RedundancyEncodingDTModeElement_type type;
+} H245RedundancyEncodingDTModeElement;
+
+EXTERN int asn1PE_H245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245RedundancyEncodingDTModeElement                 */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245RedundancyEncodingDTModeElement */
+typedef DList H245_SeqOfH245RedundancyEncodingDTModeElement;
+
+EXTERN int asn1PE_H245_SeqOfH245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingDTModeElement* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingDTModeElement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTMode                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RedundancyEncodingDTMode {
+   H245RedundancyEncodingMethod redundancyEncodingMethod;
+   H245RedundancyEncodingDTModeElement primary;
+   H245_SeqOfH245RedundancyEncodingDTModeElement secondary;
+} H245RedundancyEncodingDTMode;
+
+EXTERN int asn1PE_H245RedundancyEncodingDTMode (OOCTXT* pctxt, H245RedundancyEncodingDTMode* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingDTMode (OOCTXT* pctxt, H245RedundancyEncodingDTMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamElementMode                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplePayloadStreamElementMode {
+   struct H245ModeElementType *type;
+} H245MultiplePayloadStreamElementMode;
+
+EXTERN int asn1PE_H245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245MultiplePayloadStreamElementMode* pvalue);
+
+EXTERN int asn1PD_H245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245MultiplePayloadStreamElementMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MultiplePayloadStreamElementMode                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MultiplePayloadStreamElementMode */
+typedef DList H245_SeqOfH245MultiplePayloadStreamElementMode;
+
+EXTERN int asn1PE_H245_SeqOfH245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElementMode* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElementMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamMode                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplePayloadStreamMode {
+   H245_SeqOfH245MultiplePayloadStreamElementMode elements;
+} H245MultiplePayloadStreamMode;
+
+EXTERN int asn1PE_H245MultiplePayloadStreamMode (OOCTXT* pctxt, H245MultiplePayloadStreamMode* pvalue);
+
+EXTERN int asn1PD_H245MultiplePayloadStreamMode (OOCTXT* pctxt, H245MultiplePayloadStreamMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream_differentPort     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FECMode_rfc2733Mode_mode_separateStream_differentPort {
+   struct {
+      unsigned protectedPayloadTypePresent : 1;
+   } m;
+   ASN1UINT8 protectedSessionID;
+   ASN1UINT8 protectedPayloadType;
+} H245FECMode_rfc2733Mode_mode_separateStream_differentPort;
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort* pvalue);
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream_samePort          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FECMode_rfc2733Mode_mode_separateStream_samePort {
+   struct H245ModeElementType *protectedType;
+} H245FECMode_rfc2733Mode_mode_separateStream_samePort;
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_samePort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort* pvalue);
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_samePort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FECMode_rfc2733Mode_mode_separateStream_differentPort 1
+#define T_H245FECMode_rfc2733Mode_mode_separateStream_samePort 2
+#define T_H245FECMode_rfc2733Mode_mode_separateStream_extElem1 3
+
+typedef struct EXTERN H245FECMode_rfc2733Mode_mode_separateStream {
+   int t;
+   union {
+      /* t = 1 */
+      H245FECMode_rfc2733Mode_mode_separateStream_differentPort *differentPort;
+      /* t = 2 */
+      H245FECMode_rfc2733Mode_mode_separateStream_samePort *samePort;
+      /* t = 3 */
+   } u;
+} H245FECMode_rfc2733Mode_mode_separateStream;
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream* pvalue);
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FECMode_rfc2733Mode_mode_redundancyEncoding 1
+#define T_H245FECMode_rfc2733Mode_mode_separateStream 2
+#define T_H245FECMode_rfc2733Mode_mode_extElem1 3
+
+typedef struct EXTERN H245FECMode_rfc2733Mode_mode {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245FECMode_rfc2733Mode_mode_separateStream *separateStream;
+      /* t = 3 */
+   } u;
+} H245FECMode_rfc2733Mode_mode;
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode* pvalue);
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FECMode_rfc2733Mode {
+   H245FECMode_rfc2733Mode_mode mode;
+} H245FECMode_rfc2733Mode;
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode* pvalue);
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FECMode_rfc2733Mode       1
+#define T_H245FECMode_extElem1          2
+
+typedef struct EXTERN H245FECMode {
+   int t;
+   union {
+      /* t = 1 */
+      H245FECMode_rfc2733Mode *rfc2733Mode;
+      /* t = 2 */
+   } u;
+} H245FECMode;
+
+EXTERN int asn1PE_H245FECMode (OOCTXT* pctxt, H245FECMode* pvalue);
+
+EXTERN int asn1PD_H245FECMode (OOCTXT* pctxt, H245FECMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ModeElementType                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ModeElementType_nonStandard 1
+#define T_H245ModeElementType_videoMode 2
+#define T_H245ModeElementType_audioMode 3
+#define T_H245ModeElementType_dataMode  4
+#define T_H245ModeElementType_encryptionMode 5
+#define T_H245ModeElementType_h235Mode  6
+#define T_H245ModeElementType_multiplexedStreamMode 7
+#define T_H245ModeElementType_redundancyEncodingDTMode 8
+#define T_H245ModeElementType_multiplePayloadStreamMode 9
+#define T_H245ModeElementType_fecMode   10
+#define T_H245ModeElementType_extElem1  11
+
+typedef struct EXTERN H245ModeElementType {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245VideoMode *videoMode;
+      /* t = 3 */
+      H245AudioMode *audioMode;
+      /* t = 4 */
+      H245DataMode *dataMode;
+      /* t = 5 */
+      H245EncryptionMode *encryptionMode;
+      /* t = 6 */
+      H245H235Mode *h235Mode;
+      /* t = 7 */
+      H245MultiplexedStreamParameter *multiplexedStreamMode;
+      /* t = 8 */
+      H245RedundancyEncodingDTMode *redundancyEncodingDTMode;
+      /* t = 9 */
+      H245MultiplePayloadStreamMode *multiplePayloadStreamMode;
+      /* t = 10 */
+      H245FECMode *fecMode;
+      /* t = 11 */
+   } u;
+} H245ModeElementType;
+
+EXTERN int asn1PE_H245ModeElementType (OOCTXT* pctxt, H245ModeElementType* pvalue);
+
+EXTERN int asn1PD_H245ModeElementType (OOCTXT* pctxt, H245ModeElementType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters_adaptationLayerType_al3                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223ModeParameters_adaptationLayerType_al3 {
+   ASN1UINT8 controlFieldOctets;
+   ASN1UINT sendBufferSize;
+} H245H223ModeParameters_adaptationLayerType_al3;
+
+EXTERN int asn1PE_H245H223ModeParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType_al3* pvalue);
+
+EXTERN int asn1PD_H245H223ModeParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType_al3* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters_adaptationLayerType                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223ModeParameters_adaptationLayerType_nonStandard 1
+#define T_H245H223ModeParameters_adaptationLayerType_al1Framed 2
+#define T_H245H223ModeParameters_adaptationLayerType_al1NotFramed 3
+#define T_H245H223ModeParameters_adaptationLayerType_al2WithoutSequenceNumbers 4
+#define T_H245H223ModeParameters_adaptationLayerType_al2WithSequenceNumbers 5
+#define T_H245H223ModeParameters_adaptationLayerType_al3 6
+#define T_H245H223ModeParameters_adaptationLayerType_al1M 7
+#define T_H245H223ModeParameters_adaptationLayerType_al2M 8
+#define T_H245H223ModeParameters_adaptationLayerType_al3M 9
+#define T_H245H223ModeParameters_adaptationLayerType_extElem1 10
+
+typedef struct EXTERN H245H223ModeParameters_adaptationLayerType {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      H245H223ModeParameters_adaptationLayerType_al3 *al3;
+      /* t = 7 */
+      H245H223AL1MParameters *al1M;
+      /* t = 8 */
+      H245H223AL2MParameters *al2M;
+      /* t = 9 */
+      H245H223AL3MParameters *al3M;
+      /* t = 10 */
+   } u;
+} H245H223ModeParameters_adaptationLayerType;
+
+EXTERN int asn1PE_H245H223ModeParameters_adaptationLayerType (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType* pvalue);
+
+EXTERN int asn1PD_H245H223ModeParameters_adaptationLayerType (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223ModeParameters {
+   H245H223ModeParameters_adaptationLayerType adaptationLayerType;
+   ASN1BOOL segmentableFlag;
+} H245H223ModeParameters;
+
+EXTERN int asn1PE_H245H223ModeParameters (OOCTXT* pctxt, H245H223ModeParameters* pvalue);
+
+EXTERN int asn1PD_H245H223ModeParameters (OOCTXT* pctxt, H245H223ModeParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  V76ModeParameters                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245V76ModeParameters_suspendResumewAddress 1
+#define T_H245V76ModeParameters_suspendResumewoAddress 2
+#define T_H245V76ModeParameters_extElem1 3
+
+typedef struct EXTERN H245V76ModeParameters {
+   int t;
+} H245V76ModeParameters;
+
+EXTERN int asn1PE_H245V76ModeParameters (OOCTXT* pctxt, H245V76ModeParameters* pvalue);
+
+EXTERN int asn1PD_H245V76ModeParameters (OOCTXT* pctxt, H245V76ModeParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMode_secondaryEncoding                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RedundancyEncodingMode_secondaryEncoding_nonStandard 1
+#define T_H245RedundancyEncodingMode_secondaryEncoding_audioData 2
+#define T_H245RedundancyEncodingMode_secondaryEncoding_extElem1 3
+
+typedef struct EXTERN H245RedundancyEncodingMode_secondaryEncoding {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      H245AudioMode *audioData;
+      /* t = 3 */
+   } u;
+} H245RedundancyEncodingMode_secondaryEncoding;
+
+EXTERN int asn1PE_H245RedundancyEncodingMode_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingMode_secondaryEncoding* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingMode_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingMode_secondaryEncoding* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMode                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RedundancyEncodingMode {
+   struct {
+      unsigned secondaryEncodingPresent : 1;
+   } m;
+   H245RedundancyEncodingMethod redundancyEncodingMethod;
+   H245RedundancyEncodingMode_secondaryEncoding secondaryEncoding;
+} H245RedundancyEncodingMode;
+
+EXTERN int asn1PE_H245RedundancyEncodingMode (OOCTXT* pctxt, H245RedundancyEncodingMode* pvalue);
+
+EXTERN int asn1PD_H245RedundancyEncodingMode (OOCTXT* pctxt, H245RedundancyEncodingMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H2250ModeParameters                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H2250ModeParameters {
+   struct {
+      unsigned redundancyEncodingModePresent : 1;
+   } m;
+   H245RedundancyEncodingMode redundancyEncodingMode;
+} H245H2250ModeParameters;
+
+EXTERN int asn1PE_H245H2250ModeParameters (OOCTXT* pctxt, H245H2250ModeParameters* pvalue);
+
+EXTERN int asn1PD_H245H2250ModeParameters (OOCTXT* pctxt, H245H2250ModeParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamModeParameters                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexedStreamModeParameters {
+   H245LogicalChannelNumber logicalChannelNumber;
+} H245MultiplexedStreamModeParameters;
+
+EXTERN int asn1PE_H245MultiplexedStreamModeParameters (OOCTXT* pctxt, H245MultiplexedStreamModeParameters* pvalue);
+
+EXTERN int asn1PD_H245MultiplexedStreamModeParameters (OOCTXT* pctxt, H245MultiplexedStreamModeParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ModeElement                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ModeElement {
+   struct {
+      unsigned h223ModeParametersPresent : 1;
+      unsigned v76ModeParametersPresent : 1;
+      unsigned h2250ModeParametersPresent : 1;
+      unsigned genericModeParametersPresent : 1;
+      unsigned multiplexedStreamModeParametersPresent : 1;
+   } m;
+   H245ModeElementType type;
+   H245H223ModeParameters h223ModeParameters;
+   H245V76ModeParameters v76ModeParameters;
+   H245H2250ModeParameters h2250ModeParameters;
+   H245GenericCapability genericModeParameters;
+   H245MultiplexedStreamModeParameters multiplexedStreamModeParameters;
+} H245ModeElement;
+
+EXTERN int asn1PE_H245ModeElement (OOCTXT* pctxt, H245ModeElement* pvalue);
+
+EXTERN int asn1PD_H245ModeElement (OOCTXT* pctxt, H245ModeElement* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ModeDescription                                           */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245ModeElement */
+typedef DList H245ModeDescription;
+
+EXTERN int asn1PE_H245ModeDescription (OOCTXT* pctxt, H245ModeDescription* pvalue);
+
+EXTERN int asn1PD_H245ModeDescription (OOCTXT* pctxt, H245ModeDescription* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMode_requestedModes                                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245ModeDescription */
+typedef DList H245RequestMode_requestedModes;
+
+EXTERN int asn1PE_H245RequestMode_requestedModes (OOCTXT* pctxt, H245RequestMode_requestedModes* pvalue);
+
+EXTERN int asn1PD_H245RequestMode_requestedModes (OOCTXT* pctxt, H245RequestMode_requestedModes* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMode                                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMode {
+   H245SequenceNumber sequenceNumber;
+   H245RequestMode_requestedModes requestedModes;
+} H245RequestMode;
+
+EXTERN int asn1PE_H245RequestMode (OOCTXT* pctxt, H245RequestMode* pvalue);
+
+EXTERN int asn1PD_H245RequestMode (OOCTXT* pctxt, H245RequestMode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RoundTripDelayRequest                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RoundTripDelayRequest {
+   H245SequenceNumber sequenceNumber;
+} H245RoundTripDelayRequest;
+
+EXTERN int asn1PE_H245RoundTripDelayRequest (OOCTXT* pctxt, H245RoundTripDelayRequest* pvalue);
+
+EXTERN int asn1PD_H245RoundTripDelayRequest (OOCTXT* pctxt, H245RoundTripDelayRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopRequest_type                               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MaintenanceLoopRequest_type_systemLoop 1
+#define T_H245MaintenanceLoopRequest_type_mediaLoop 2
+#define T_H245MaintenanceLoopRequest_type_logicalChannelLoop 3
+#define T_H245MaintenanceLoopRequest_type_extElem1 4
+
+typedef struct EXTERN H245MaintenanceLoopRequest_type {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245LogicalChannelNumber mediaLoop;
+      /* t = 3 */
+      H245LogicalChannelNumber logicalChannelLoop;
+      /* t = 4 */
+   } u;
+} H245MaintenanceLoopRequest_type;
+
+EXTERN int asn1PE_H245MaintenanceLoopRequest_type (OOCTXT* pctxt, H245MaintenanceLoopRequest_type* pvalue);
+
+EXTERN int asn1PD_H245MaintenanceLoopRequest_type (OOCTXT* pctxt, H245MaintenanceLoopRequest_type* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopRequest                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MaintenanceLoopRequest {
+   H245MaintenanceLoopRequest_type type;
+} H245MaintenanceLoopRequest;
+
+EXTERN int asn1PE_H245MaintenanceLoopRequest (OOCTXT* pctxt, H245MaintenanceLoopRequest* pvalue);
+
+EXTERN int asn1PD_H245MaintenanceLoopRequest (OOCTXT* pctxt, H245MaintenanceLoopRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeRequest                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CommunicationModeRequest {
+   ASN1OCTET __dummy__;
+} H245CommunicationModeRequest;
+
+EXTERN int asn1PE_H245CommunicationModeRequest (OOCTXT* pctxt, H245CommunicationModeRequest* pvalue);
+
+EXTERN int asn1PD_H245CommunicationModeRequest (OOCTXT* pctxt, H245CommunicationModeRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Criteria                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245Criteria {
+   ASN1OBJID field;
+   ASN1DynOctStr value;
+} H245Criteria;
+
+EXTERN int asn1PE_H245Criteria (OOCTXT* pctxt, H245Criteria* pvalue);
+
+EXTERN int asn1PD_H245Criteria (OOCTXT* pctxt, H245Criteria* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CertSelectionCriteria                                     */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245Criteria */
+typedef DList H245CertSelectionCriteria;
+
+EXTERN int asn1PE_H245CertSelectionCriteria (OOCTXT* pctxt, H245CertSelectionCriteria* pvalue);
+
+EXTERN int asn1PD_H245CertSelectionCriteria (OOCTXT* pctxt, H245CertSelectionCriteria* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceRequest_requestTerminalCertificate              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceRequest_requestTerminalCertificate {
+   struct {
+      unsigned terminalLabelPresent : 1;
+      unsigned certSelectionCriteriaPresent : 1;
+      unsigned sRandomPresent : 1;
+   } m;
+   H245TerminalLabel terminalLabel;
+   H245CertSelectionCriteria certSelectionCriteria;
+   ASN1UINT sRandom;
+} H245ConferenceRequest_requestTerminalCertificate;
+
+EXTERN int asn1PE_H245ConferenceRequest_requestTerminalCertificate (OOCTXT* pctxt, H245ConferenceRequest_requestTerminalCertificate* pvalue);
+
+EXTERN int asn1PD_H245ConferenceRequest_requestTerminalCertificate (OOCTXT* pctxt, H245ConferenceRequest_requestTerminalCertificate* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCRequest                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RemoteMCRequest_masterActivate 1
+#define T_H245RemoteMCRequest_slaveActivate 2
+#define T_H245RemoteMCRequest_deActivate 3
+#define T_H245RemoteMCRequest_extElem1  4
+
+typedef struct EXTERN H245RemoteMCRequest {
+   int t;
+} H245RemoteMCRequest;
+
+EXTERN int asn1PE_H245RemoteMCRequest (OOCTXT* pctxt, H245RemoteMCRequest* pvalue);
+
+EXTERN int asn1PD_H245RemoteMCRequest (OOCTXT* pctxt, H245RemoteMCRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceRequest                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ConferenceRequest_terminalListRequest 1
+#define T_H245ConferenceRequest_makeMeChair 2
+#define T_H245ConferenceRequest_cancelMakeMeChair 3
+#define T_H245ConferenceRequest_dropTerminal 4
+#define T_H245ConferenceRequest_requestTerminalID 5
+#define T_H245ConferenceRequest_enterH243Password 6
+#define T_H245ConferenceRequest_enterH243TerminalID 7
+#define T_H245ConferenceRequest_enterH243ConferenceID 8
+#define T_H245ConferenceRequest_enterExtensionAddress 9
+#define T_H245ConferenceRequest_requestChairTokenOwner 10
+#define T_H245ConferenceRequest_requestTerminalCertificate 11
+#define T_H245ConferenceRequest_broadcastMyLogicalChannel 12
+#define T_H245ConferenceRequest_makeTerminalBroadcaster 13
+#define T_H245ConferenceRequest_sendThisSource 14
+#define T_H245ConferenceRequest_requestAllTerminalIDs 15
+#define T_H245ConferenceRequest_remoteMCRequest 16
+#define T_H245ConferenceRequest_extElem1 17
+
+typedef struct EXTERN H245ConferenceRequest {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      H245TerminalLabel *dropTerminal;
+      /* t = 5 */
+      H245TerminalLabel *requestTerminalID;
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      /* t = 9 */
+      /* t = 10 */
+      /* t = 11 */
+      H245ConferenceRequest_requestTerminalCertificate *requestTerminalCertificate;
+      /* t = 12 */
+      H245LogicalChannelNumber broadcastMyLogicalChannel;
+      /* t = 13 */
+      H245TerminalLabel *makeTerminalBroadcaster;
+      /* t = 14 */
+      H245TerminalLabel *sendThisSource;
+      /* t = 15 */
+      /* t = 16 */
+      H245RemoteMCRequest *remoteMCRequest;
+      /* t = 17 */
+   } u;
+} H245ConferenceRequest;
+
+EXTERN int asn1PE_H245ConferenceRequest (OOCTXT* pctxt, H245ConferenceRequest* pvalue);
+
+EXTERN int asn1PD_H245ConferenceRequest (OOCTXT* pctxt, H245ConferenceRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_callInformation                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkRequest_callInformation {
+   ASN1USINT maxNumberOfAdditionalConnections;
+} H245MultilinkRequest_callInformation;
+
+EXTERN int asn1PE_H245MultilinkRequest_callInformation (OOCTXT* pctxt, H245MultilinkRequest_callInformation* pvalue);
+
+EXTERN int asn1PD_H245MultilinkRequest_callInformation (OOCTXT* pctxt, H245MultilinkRequest_callInformation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNetworkType                             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245DialingInformationNetworkType_nonStandard 1
+#define T_H245DialingInformationNetworkType_n_isdn 2
+#define T_H245DialingInformationNetworkType_gstn 3
+#define T_H245DialingInformationNetworkType_mobile 4
+#define T_H245DialingInformationNetworkType_extElem1 5
+
+typedef struct EXTERN H245DialingInformationNetworkType {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+   } u;
+} H245DialingInformationNetworkType;
+
+EXTERN int asn1PE_H245DialingInformationNetworkType (OOCTXT* pctxt, H245DialingInformationNetworkType* pvalue);
+
+EXTERN int asn1PD_H245DialingInformationNetworkType (OOCTXT* pctxt, H245DialingInformationNetworkType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNumber_networkType                      */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245DialingInformationNetworkType */
+typedef DList H245DialingInformationNumber_networkType;
+
+EXTERN int asn1PE_H245DialingInformationNumber_networkType (OOCTXT* pctxt, H245DialingInformationNumber_networkType* pvalue);
+
+EXTERN int asn1PD_H245DialingInformationNumber_networkType (OOCTXT* pctxt, H245DialingInformationNumber_networkType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNumber                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245DialingInformationNumber {
+   struct {
+      unsigned subAddressPresent : 1;
+   } m;
+   ASN1NumericString networkAddress;
+   ASN1IA5String subAddress;
+   H245DialingInformationNumber_networkType networkType;
+} H245DialingInformationNumber;
+
+EXTERN int asn1PE_H245DialingInformationNumber (OOCTXT* pctxt, H245DialingInformationNumber* pvalue);
+
+EXTERN int asn1PD_H245DialingInformationNumber (OOCTXT* pctxt, H245DialingInformationNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformation_differential                           */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245DialingInformationNumber */
+typedef DList H245DialingInformation_differential;
+
+EXTERN int asn1PE_H245DialingInformation_differential (OOCTXT* pctxt, H245DialingInformation_differential* pvalue);
+
+EXTERN int asn1PD_H245DialingInformation_differential (OOCTXT* pctxt, H245DialingInformation_differential* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformation                                        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245DialingInformation_nonStandard 1
+#define T_H245DialingInformation_differential 2
+#define T_H245DialingInformation_infoNotAvailable 3
+#define T_H245DialingInformation_extElem1 4
+
+typedef struct EXTERN H245DialingInformation {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      H245DialingInformation_differential *differential;
+      /* t = 3 */
+      ASN1USINT infoNotAvailable;
+      /* t = 4 */
+   } u;
+} H245DialingInformation;
+
+EXTERN int asn1PE_H245DialingInformation (OOCTXT* pctxt, H245DialingInformation* pvalue);
+
+EXTERN int asn1PD_H245DialingInformation (OOCTXT* pctxt, H245DialingInformation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_addConnection                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkRequest_addConnection {
+   H245SequenceNumber sequenceNumber;
+   H245DialingInformation dialingInformation;
+} H245MultilinkRequest_addConnection;
+
+EXTERN int asn1PE_H245MultilinkRequest_addConnection (OOCTXT* pctxt, H245MultilinkRequest_addConnection* pvalue);
+
+EXTERN int asn1PD_H245MultilinkRequest_addConnection (OOCTXT* pctxt, H245MultilinkRequest_addConnection* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConnectionIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConnectionIdentifier {
+   ASN1UINT channelTag;
+   ASN1UINT sequenceNumber;
+} H245ConnectionIdentifier;
+
+EXTERN int asn1PE_H245ConnectionIdentifier (OOCTXT* pctxt, H245ConnectionIdentifier* pvalue);
+
+EXTERN int asn1PD_H245ConnectionIdentifier (OOCTXT* pctxt, H245ConnectionIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_removeConnection                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkRequest_removeConnection {
+   H245ConnectionIdentifier connectionIdentifier;
+} H245MultilinkRequest_removeConnection;
+
+EXTERN int asn1PE_H245MultilinkRequest_removeConnection (OOCTXT* pctxt, H245MultilinkRequest_removeConnection* pvalue);
+
+EXTERN int asn1PD_H245MultilinkRequest_removeConnection (OOCTXT* pctxt, H245MultilinkRequest_removeConnection* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_maximumHeaderInterval_requestType        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultilinkRequest_maximumHeaderInterval_requestType_currentIntervalInformation 1
+#define T_H245MultilinkRequest_maximumHeaderInterval_requestType_requestedInterval 2
+#define T_H245MultilinkRequest_maximumHeaderInterval_requestType_extElem1 3
+
+typedef struct EXTERN H245MultilinkRequest_maximumHeaderInterval_requestType {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      ASN1USINT requestedInterval;
+      /* t = 3 */
+   } u;
+} H245MultilinkRequest_maximumHeaderInterval_requestType;
+
+EXTERN int asn1PE_H245MultilinkRequest_maximumHeaderInterval_requestType (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval_requestType* pvalue);
+
+EXTERN int asn1PD_H245MultilinkRequest_maximumHeaderInterval_requestType (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval_requestType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_maximumHeaderInterval                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkRequest_maximumHeaderInterval {
+   H245MultilinkRequest_maximumHeaderInterval_requestType requestType;
+} H245MultilinkRequest_maximumHeaderInterval;
+
+EXTERN int asn1PE_H245MultilinkRequest_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval* pvalue);
+
+EXTERN int asn1PD_H245MultilinkRequest_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultilinkRequest_nonStandard 1
+#define T_H245MultilinkRequest_callInformation 2
+#define T_H245MultilinkRequest_addConnection 3
+#define T_H245MultilinkRequest_removeConnection 4
+#define T_H245MultilinkRequest_maximumHeaderInterval 5
+#define T_H245MultilinkRequest_extElem1 6
+
+typedef struct EXTERN H245MultilinkRequest {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      H245MultilinkRequest_callInformation *callInformation;
+      /* t = 3 */
+      H245MultilinkRequest_addConnection *addConnection;
+      /* t = 4 */
+      H245MultilinkRequest_removeConnection *removeConnection;
+      /* t = 5 */
+      H245MultilinkRequest_maximumHeaderInterval *maximumHeaderInterval;
+      /* t = 6 */
+   } u;
+} H245MultilinkRequest;
+
+EXTERN int asn1PE_H245MultilinkRequest (OOCTXT* pctxt, H245MultilinkRequest* pvalue);
+
+EXTERN int asn1PD_H245MultilinkRequest (OOCTXT* pctxt, H245MultilinkRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaximumBitRate                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef ASN1UINT H245MaximumBitRate;
+
+EXTERN int asn1PE_H245MaximumBitRate (OOCTXT* pctxt, H245MaximumBitRate value);
+
+EXTERN int asn1PD_H245MaximumBitRate (OOCTXT* pctxt, H245MaximumBitRate* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRequest                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245LogicalChannelRateRequest {
+   H245SequenceNumber sequenceNumber;
+   H245LogicalChannelNumber logicalChannelNumber;
+   H245MaximumBitRate maximumBitRate;
+} H245LogicalChannelRateRequest;
+
+EXTERN int asn1PE_H245LogicalChannelRateRequest (OOCTXT* pctxt, H245LogicalChannelRateRequest* pvalue);
+
+EXTERN int asn1PD_H245LogicalChannelRateRequest (OOCTXT* pctxt, H245LogicalChannelRateRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMessage                                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RequestMessage_nonStandard 1
+#define T_H245RequestMessage_masterSlaveDetermination 2
+#define T_H245RequestMessage_terminalCapabilitySet 3
+#define T_H245RequestMessage_openLogicalChannel 4
+#define T_H245RequestMessage_closeLogicalChannel 5
+#define T_H245RequestMessage_requestChannelClose 6
+#define T_H245RequestMessage_multiplexEntrySend 7
+#define T_H245RequestMessage_requestMultiplexEntry 8
+#define T_H245RequestMessage_requestMode 9
+#define T_H245RequestMessage_roundTripDelayRequest 10
+#define T_H245RequestMessage_maintenanceLoopRequest 11
+#define T_H245RequestMessage_communicationModeRequest 12
+#define T_H245RequestMessage_conferenceRequest 13
+#define T_H245RequestMessage_multilinkRequest 14
+#define T_H245RequestMessage_logicalChannelRateRequest 15
+#define T_H245RequestMessage_extElem1   16
+
+typedef struct EXTERN H245RequestMessage {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      H245MasterSlaveDetermination *masterSlaveDetermination;
+      /* t = 3 */
+      H245TerminalCapabilitySet *terminalCapabilitySet;
+      /* t = 4 */
+      H245OpenLogicalChannel *openLogicalChannel;
+      /* t = 5 */
+      H245CloseLogicalChannel *closeLogicalChannel;
+      /* t = 6 */
+      H245RequestChannelClose *requestChannelClose;
+      /* t = 7 */
+      H245MultiplexEntrySend *multiplexEntrySend;
+      /* t = 8 */
+      H245RequestMultiplexEntry *requestMultiplexEntry;
+      /* t = 9 */
+      H245RequestMode *requestMode;
+      /* t = 10 */
+      H245RoundTripDelayRequest *roundTripDelayRequest;
+      /* t = 11 */
+      H245MaintenanceLoopRequest *maintenanceLoopRequest;
+      /* t = 12 */
+      H245CommunicationModeRequest *communicationModeRequest;
+      /* t = 13 */
+      H245ConferenceRequest *conferenceRequest;
+      /* t = 14 */
+      H245MultilinkRequest *multilinkRequest;
+      /* t = 15 */
+      H245LogicalChannelRateRequest *logicalChannelRateRequest;
+      /* t = 16 */
+   } u;
+} H245RequestMessage;
+
+EXTERN int asn1PE_H245RequestMessage (OOCTXT* pctxt, H245RequestMessage* pvalue);
+
+EXTERN int asn1PD_H245RequestMessage (OOCTXT* pctxt, H245RequestMessage* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationAck_decision                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MasterSlaveDeterminationAck_decision_master 1
+#define T_H245MasterSlaveDeterminationAck_decision_slave 2
+
+typedef struct EXTERN H245MasterSlaveDeterminationAck_decision {
+   int t;
+} H245MasterSlaveDeterminationAck_decision;
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationAck_decision (OOCTXT* pctxt, H245MasterSlaveDeterminationAck_decision* pvalue);
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationAck_decision (OOCTXT* pctxt, H245MasterSlaveDeterminationAck_decision* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationAck                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MasterSlaveDeterminationAck {
+   H245MasterSlaveDeterminationAck_decision decision;
+} H245MasterSlaveDeterminationAck;
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationAck (OOCTXT* pctxt, H245MasterSlaveDeterminationAck* pvalue);
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationAck (OOCTXT* pctxt, H245MasterSlaveDeterminationAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationReject_cause                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MasterSlaveDeterminationReject_cause_identicalNumbers 1
+#define T_H245MasterSlaveDeterminationReject_cause_extElem1 2
+
+typedef struct EXTERN H245MasterSlaveDeterminationReject_cause {
+   int t;
+} H245MasterSlaveDeterminationReject_cause;
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationReject_cause (OOCTXT* pctxt, H245MasterSlaveDeterminationReject_cause* pvalue);
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationReject_cause (OOCTXT* pctxt, H245MasterSlaveDeterminationReject_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationReject                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MasterSlaveDeterminationReject {
+   H245MasterSlaveDeterminationReject_cause cause;
+} H245MasterSlaveDeterminationReject;
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationReject (OOCTXT* pctxt, H245MasterSlaveDeterminationReject* pvalue);
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationReject (OOCTXT* pctxt, H245MasterSlaveDeterminationReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetAck                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TerminalCapabilitySetAck {
+   H245SequenceNumber sequenceNumber;
+} H245TerminalCapabilitySetAck;
+
+EXTERN int asn1PE_H245TerminalCapabilitySetAck (OOCTXT* pctxt, H245TerminalCapabilitySetAck* pvalue);
+
+EXTERN int asn1PD_H245TerminalCapabilitySetAck (OOCTXT* pctxt, H245TerminalCapabilitySetAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject_cause_tableEntryCapacityExce  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded_highestEntryNumberProcessed 1
+#define T_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded_noneProcessed 2
+
+typedef struct EXTERN H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded {
+   int t;
+   union {
+      /* t = 1 */
+      H245CapabilityTableEntryNumber highestEntryNumberProcessed;
+      /* t = 2 */
+   } u;
+} H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded;
+
+EXTERN int asn1PE_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded* pvalue);
+
+EXTERN int asn1PD_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject_cause                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245TerminalCapabilitySetReject_cause_unspecified 1
+#define T_H245TerminalCapabilitySetReject_cause_undefinedTableEntryUsed 2
+#define T_H245TerminalCapabilitySetReject_cause_descriptorCapacityExceeded 3
+#define T_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded 4
+#define T_H245TerminalCapabilitySetReject_cause_extElem1 5
+
+typedef struct EXTERN H245TerminalCapabilitySetReject_cause {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded *tableEntryCapacityExceeded;
+      /* t = 5 */
+   } u;
+} H245TerminalCapabilitySetReject_cause;
+
+EXTERN int asn1PE_H245TerminalCapabilitySetReject_cause (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause* pvalue);
+
+EXTERN int asn1PD_H245TerminalCapabilitySetReject_cause (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TerminalCapabilitySetReject {
+   H245SequenceNumber sequenceNumber;
+   H245TerminalCapabilitySetReject_cause cause;
+} H245TerminalCapabilitySetReject;
+
+EXTERN int asn1PE_H245TerminalCapabilitySetReject (OOCTXT* pctxt, H245TerminalCapabilitySetReject* pvalue);
+
+EXTERN int asn1PD_H245TerminalCapabilitySetReject (OOCTXT* pctxt, H245TerminalCapabilitySetReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_reverseLogicalChannelParameters_mu  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h222LogicalChannelParameters 1
+#define T_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters 2
+#define T_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_extElem1 3
+
+typedef struct EXTERN H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters {
+   int t;
+   union {
+      /* t = 1 */
+      H245H222LogicalChannelParameters *h222LogicalChannelParameters;
+      /* t = 2 */
+      H245H2250LogicalChannelParameters *h2250LogicalChannelParameters;
+      /* t = 3 */
+   } u;
+} H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters;
+
+EXTERN int asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_reverseLogicalChannelParameters     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245OpenLogicalChannelAck_reverseLogicalChannelParameters {
+   struct {
+      unsigned portNumberPresent : 1;
+      unsigned multiplexParametersPresent : 1;
+      unsigned replacementForPresent : 1;
+   } m;
+   H245LogicalChannelNumber reverseLogicalChannelNumber;
+   ASN1USINT portNumber;
+   H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters multiplexParameters;
+   H245LogicalChannelNumber replacementFor;
+} H245OpenLogicalChannelAck_reverseLogicalChannelParameters;
+
+EXTERN int asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelAckParameters                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H2250LogicalChannelAckParameters {
+   struct {
+      unsigned nonStandardPresent : 1;
+      unsigned sessionIDPresent : 1;
+      unsigned mediaChannelPresent : 1;
+      unsigned mediaControlChannelPresent : 1;
+      unsigned dynamicRTPPayloadTypePresent : 1;
+      unsigned flowControlToZeroPresent : 1;
+      unsigned portNumberPresent : 1;
+   } m;
+   H245_SeqOfH245NonStandardParameter nonStandard;
+   ASN1UINT8 sessionID;
+   H245TransportAddress mediaChannel;
+   H245TransportAddress mediaControlChannel;
+   ASN1UINT8 dynamicRTPPayloadType;
+   ASN1BOOL flowControlToZero;
+   ASN1USINT portNumber;
+} H245H2250LogicalChannelAckParameters;
+
+EXTERN int asn1PE_H245H2250LogicalChannelAckParameters (OOCTXT* pctxt, H245H2250LogicalChannelAckParameters* pvalue);
+
+EXTERN int asn1PD_H245H2250LogicalChannelAckParameters (OOCTXT* pctxt, H245H2250LogicalChannelAckParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_forwardMultiplexAckParameters       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245OpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters 1
+#define T_H245OpenLogicalChannelAck_forwardMultiplexAckParameters_extElem1 2
+
+typedef struct EXTERN H245OpenLogicalChannelAck_forwardMultiplexAckParameters {
+   int t;
+   union {
+      /* t = 1 */
+      H245H2250LogicalChannelAckParameters *h2250LogicalChannelAckParameters;
+      /* t = 2 */
+   } u;
+} H245OpenLogicalChannelAck_forwardMultiplexAckParameters;
+
+EXTERN int asn1PE_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_forwardMultiplexAckParameters* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_forwardMultiplexAckParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245OpenLogicalChannelAck {
+   struct {
+      unsigned reverseLogicalChannelParametersPresent : 1;
+      unsigned separateStackPresent : 1;
+      unsigned forwardMultiplexAckParametersPresent : 1;
+      unsigned encryptionSyncPresent : 1;
+   } m;
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+   H245OpenLogicalChannelAck_reverseLogicalChannelParameters reverseLogicalChannelParameters;
+   H245NetworkAccessParameters separateStack;
+   H245OpenLogicalChannelAck_forwardMultiplexAckParameters forwardMultiplexAckParameters;
+   H245EncryptionSync encryptionSync;
+} H245OpenLogicalChannelAck;
+
+EXTERN int asn1PE_H245OpenLogicalChannelAck (OOCTXT* pctxt, H245OpenLogicalChannelAck* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannelAck (OOCTXT* pctxt, H245OpenLogicalChannelAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelReject_cause                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245OpenLogicalChannelReject_cause_unspecified 1
+#define T_H245OpenLogicalChannelReject_cause_unsuitableReverseParameters 2
+#define T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported 3
+#define T_H245OpenLogicalChannelReject_cause_dataTypeNotAvailable 4
+#define T_H245OpenLogicalChannelReject_cause_unknownDataType 5
+#define T_H245OpenLogicalChannelReject_cause_dataTypeALCombinationNotSupported 6
+#define T_H245OpenLogicalChannelReject_cause_multicastChannelNotAllowed 7
+#define T_H245OpenLogicalChannelReject_cause_insufficientBandwidth 8
+#define T_H245OpenLogicalChannelReject_cause_separateStackEstablishmentFailed 9
+#define T_H245OpenLogicalChannelReject_cause_invalidSessionID 10
+#define T_H245OpenLogicalChannelReject_cause_masterSlaveConflict 11
+#define T_H245OpenLogicalChannelReject_cause_waitForCommunicationMode 12
+#define T_H245OpenLogicalChannelReject_cause_invalidDependentChannel 13
+#define T_H245OpenLogicalChannelReject_cause_replacementForRejected 14
+#define T_H245OpenLogicalChannelReject_cause_extElem1 15
+
+typedef struct EXTERN H245OpenLogicalChannelReject_cause {
+   int t;
+} H245OpenLogicalChannelReject_cause;
+
+EXTERN int asn1PE_H245OpenLogicalChannelReject_cause (OOCTXT* pctxt, H245OpenLogicalChannelReject_cause* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannelReject_cause (OOCTXT* pctxt, H245OpenLogicalChannelReject_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelReject                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245OpenLogicalChannelReject {
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+   H245OpenLogicalChannelReject_cause cause;
+} H245OpenLogicalChannelReject;
+
+EXTERN int asn1PE_H245OpenLogicalChannelReject (OOCTXT* pctxt, H245OpenLogicalChannelReject* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannelReject (OOCTXT* pctxt, H245OpenLogicalChannelReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannelAck                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CloseLogicalChannelAck {
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+} H245CloseLogicalChannelAck;
+
+EXTERN int asn1PE_H245CloseLogicalChannelAck (OOCTXT* pctxt, H245CloseLogicalChannelAck* pvalue);
+
+EXTERN int asn1PD_H245CloseLogicalChannelAck (OOCTXT* pctxt, H245CloseLogicalChannelAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseAck                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestChannelCloseAck {
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+} H245RequestChannelCloseAck;
+
+EXTERN int asn1PE_H245RequestChannelCloseAck (OOCTXT* pctxt, H245RequestChannelCloseAck* pvalue);
+
+EXTERN int asn1PD_H245RequestChannelCloseAck (OOCTXT* pctxt, H245RequestChannelCloseAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseReject_cause                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RequestChannelCloseReject_cause_unspecified 1
+#define T_H245RequestChannelCloseReject_cause_extElem1 2
+
+typedef struct EXTERN H245RequestChannelCloseReject_cause {
+   int t;
+} H245RequestChannelCloseReject_cause;
+
+EXTERN int asn1PE_H245RequestChannelCloseReject_cause (OOCTXT* pctxt, H245RequestChannelCloseReject_cause* pvalue);
+
+EXTERN int asn1PD_H245RequestChannelCloseReject_cause (OOCTXT* pctxt, H245RequestChannelCloseReject_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseReject                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestChannelCloseReject {
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+   H245RequestChannelCloseReject_cause cause;
+} H245RequestChannelCloseReject;
+
+EXTERN int asn1PE_H245RequestChannelCloseReject (OOCTXT* pctxt, H245RequestChannelCloseReject* pvalue);
+
+EXTERN int asn1PD_H245RequestChannelCloseReject (OOCTXT* pctxt, H245RequestChannelCloseReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendAck_multiplexTableEntryNumber           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexEntrySendAck_multiplexTableEntryNumber {
+   ASN1UINT n;
+   H245MultiplexTableEntryNumber elem[15];
+} H245MultiplexEntrySendAck_multiplexTableEntryNumber;
+
+EXTERN int asn1PE_H245MultiplexEntrySendAck_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendAck_multiplexTableEntryNumber* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntrySendAck_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendAck_multiplexTableEntryNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendAck                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexEntrySendAck {
+   H245SequenceNumber sequenceNumber;
+   H245MultiplexEntrySendAck_multiplexTableEntryNumber multiplexTableEntryNumber;
+} H245MultiplexEntrySendAck;
+
+EXTERN int asn1PE_H245MultiplexEntrySendAck (OOCTXT* pctxt, H245MultiplexEntrySendAck* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntrySendAck (OOCTXT* pctxt, H245MultiplexEntrySendAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryRejectionDescriptions_cause                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultiplexEntryRejectionDescriptions_cause_unspecifiedCause 1
+#define T_H245MultiplexEntryRejectionDescriptions_cause_descriptorTooComplex 2
+#define T_H245MultiplexEntryRejectionDescriptions_cause_extElem1 3
+
+typedef struct EXTERN H245MultiplexEntryRejectionDescriptions_cause {
+   int t;
+} H245MultiplexEntryRejectionDescriptions_cause;
+
+EXTERN int asn1PE_H245MultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions_cause* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryRejectionDescriptions                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexEntryRejectionDescriptions {
+   H245MultiplexTableEntryNumber multiplexTableEntryNumber;
+   H245MultiplexEntryRejectionDescriptions_cause cause;
+} H245MultiplexEntryRejectionDescriptions;
+
+EXTERN int asn1PE_H245MultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendReject_rejectionDescriptions            */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245MultiplexEntryRejectionDescriptions */
+typedef DList H245MultiplexEntrySendReject_rejectionDescriptions;
+
+EXTERN int asn1PE_H245MultiplexEntrySendReject_rejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntrySendReject_rejectionDescriptions* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntrySendReject_rejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntrySendReject_rejectionDescriptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendReject                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexEntrySendReject {
+   H245SequenceNumber sequenceNumber;
+   H245MultiplexEntrySendReject_rejectionDescriptions rejectionDescriptions;
+} H245MultiplexEntrySendReject;
+
+EXTERN int asn1PE_H245MultiplexEntrySendReject (OOCTXT* pctxt, H245MultiplexEntrySendReject* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntrySendReject (OOCTXT* pctxt, H245MultiplexEntrySendReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryAck_entryNumbers                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntryAck_entryNumbers {
+   ASN1UINT n;
+   H245MultiplexTableEntryNumber elem[15];
+} H245RequestMultiplexEntryAck_entryNumbers;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryAck_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryAck_entryNumbers* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryAck_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryAck_entryNumbers* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryAck                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntryAck {
+   H245RequestMultiplexEntryAck_entryNumbers entryNumbers;
+} H245RequestMultiplexEntryAck;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryAck (OOCTXT* pctxt, H245RequestMultiplexEntryAck* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryAck (OOCTXT* pctxt, H245RequestMultiplexEntryAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject_entryNumbers                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntryReject_entryNumbers {
+   ASN1UINT n;
+   H245MultiplexTableEntryNumber elem[15];
+} H245RequestMultiplexEntryReject_entryNumbers;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryReject_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryReject_entryNumbers* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryReject_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryReject_entryNumbers* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRejectionDescriptions_cause          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RequestMultiplexEntryRejectionDescriptions_cause_unspecifiedCause 1
+#define T_H245RequestMultiplexEntryRejectionDescriptions_cause_extElem1 2
+
+typedef struct EXTERN H245RequestMultiplexEntryRejectionDescriptions_cause {
+   int t;
+} H245RequestMultiplexEntryRejectionDescriptions_cause;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions_cause* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRejectionDescriptions                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntryRejectionDescriptions {
+   H245MultiplexTableEntryNumber multiplexTableEntryNumber;
+   H245RequestMultiplexEntryRejectionDescriptions_cause cause;
+} H245RequestMultiplexEntryRejectionDescriptions;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject_rejectionDescriptions         */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245RequestMultiplexEntryRejectionDescriptions */
+typedef DList H245RequestMultiplexEntryReject_rejectionDescriptions;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryReject_rejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryReject_rejectionDescriptions* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryReject_rejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryReject_rejectionDescriptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntryReject {
+   H245RequestMultiplexEntryReject_entryNumbers entryNumbers;
+   H245RequestMultiplexEntryReject_rejectionDescriptions rejectionDescriptions;
+} H245RequestMultiplexEntryReject;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryReject (OOCTXT* pctxt, H245RequestMultiplexEntryReject* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryReject (OOCTXT* pctxt, H245RequestMultiplexEntryReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeAck_response                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RequestModeAck_response_willTransmitMostPreferredMode 1
+#define T_H245RequestModeAck_response_willTransmitLessPreferredMode 2
+#define T_H245RequestModeAck_response_extElem1 3
+
+typedef struct EXTERN H245RequestModeAck_response {
+   int t;
+} H245RequestModeAck_response;
+
+EXTERN int asn1PE_H245RequestModeAck_response (OOCTXT* pctxt, H245RequestModeAck_response* pvalue);
+
+EXTERN int asn1PD_H245RequestModeAck_response (OOCTXT* pctxt, H245RequestModeAck_response* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeAck                                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestModeAck {
+   H245SequenceNumber sequenceNumber;
+   H245RequestModeAck_response response;
+} H245RequestModeAck;
+
+EXTERN int asn1PE_H245RequestModeAck (OOCTXT* pctxt, H245RequestModeAck* pvalue);
+
+EXTERN int asn1PD_H245RequestModeAck (OOCTXT* pctxt, H245RequestModeAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeReject_cause                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RequestModeReject_cause_modeUnavailable 1
+#define T_H245RequestModeReject_cause_multipointConstraint 2
+#define T_H245RequestModeReject_cause_requestDenied 3
+#define T_H245RequestModeReject_cause_extElem1 4
+
+typedef struct EXTERN H245RequestModeReject_cause {
+   int t;
+} H245RequestModeReject_cause;
+
+EXTERN int asn1PE_H245RequestModeReject_cause (OOCTXT* pctxt, H245RequestModeReject_cause* pvalue);
+
+EXTERN int asn1PD_H245RequestModeReject_cause (OOCTXT* pctxt, H245RequestModeReject_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeReject                                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestModeReject {
+   H245SequenceNumber sequenceNumber;
+   H245RequestModeReject_cause cause;
+} H245RequestModeReject;
+
+EXTERN int asn1PE_H245RequestModeReject (OOCTXT* pctxt, H245RequestModeReject* pvalue);
+
+EXTERN int asn1PD_H245RequestModeReject (OOCTXT* pctxt, H245RequestModeReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RoundTripDelayResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RoundTripDelayResponse {
+   H245SequenceNumber sequenceNumber;
+} H245RoundTripDelayResponse;
+
+EXTERN int asn1PE_H245RoundTripDelayResponse (OOCTXT* pctxt, H245RoundTripDelayResponse* pvalue);
+
+EXTERN int asn1PD_H245RoundTripDelayResponse (OOCTXT* pctxt, H245RoundTripDelayResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopAck_type                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MaintenanceLoopAck_type_systemLoop 1
+#define T_H245MaintenanceLoopAck_type_mediaLoop 2
+#define T_H245MaintenanceLoopAck_type_logicalChannelLoop 3
+#define T_H245MaintenanceLoopAck_type_extElem1 4
+
+typedef struct EXTERN H245MaintenanceLoopAck_type {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245LogicalChannelNumber mediaLoop;
+      /* t = 3 */
+      H245LogicalChannelNumber logicalChannelLoop;
+      /* t = 4 */
+   } u;
+} H245MaintenanceLoopAck_type;
+
+EXTERN int asn1PE_H245MaintenanceLoopAck_type (OOCTXT* pctxt, H245MaintenanceLoopAck_type* pvalue);
+
+EXTERN int asn1PD_H245MaintenanceLoopAck_type (OOCTXT* pctxt, H245MaintenanceLoopAck_type* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopAck                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MaintenanceLoopAck {
+   H245MaintenanceLoopAck_type type;
+} H245MaintenanceLoopAck;
+
+EXTERN int asn1PE_H245MaintenanceLoopAck (OOCTXT* pctxt, H245MaintenanceLoopAck* pvalue);
+
+EXTERN int asn1PD_H245MaintenanceLoopAck (OOCTXT* pctxt, H245MaintenanceLoopAck* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject_type                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MaintenanceLoopReject_type_systemLoop 1
+#define T_H245MaintenanceLoopReject_type_mediaLoop 2
+#define T_H245MaintenanceLoopReject_type_logicalChannelLoop 3
+#define T_H245MaintenanceLoopReject_type_extElem1 4
+
+typedef struct EXTERN H245MaintenanceLoopReject_type {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245LogicalChannelNumber mediaLoop;
+      /* t = 3 */
+      H245LogicalChannelNumber logicalChannelLoop;
+      /* t = 4 */
+   } u;
+} H245MaintenanceLoopReject_type;
+
+EXTERN int asn1PE_H245MaintenanceLoopReject_type (OOCTXT* pctxt, H245MaintenanceLoopReject_type* pvalue);
+
+EXTERN int asn1PD_H245MaintenanceLoopReject_type (OOCTXT* pctxt, H245MaintenanceLoopReject_type* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject_cause                               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MaintenanceLoopReject_cause_canNotPerformLoop 1
+#define T_H245MaintenanceLoopReject_cause_extElem1 2
+
+typedef struct EXTERN H245MaintenanceLoopReject_cause {
+   int t;
+} H245MaintenanceLoopReject_cause;
+
+EXTERN int asn1PE_H245MaintenanceLoopReject_cause (OOCTXT* pctxt, H245MaintenanceLoopReject_cause* pvalue);
+
+EXTERN int asn1PD_H245MaintenanceLoopReject_cause (OOCTXT* pctxt, H245MaintenanceLoopReject_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MaintenanceLoopReject {
+   H245MaintenanceLoopReject_type type;
+   H245MaintenanceLoopReject_cause cause;
+} H245MaintenanceLoopReject;
+
+EXTERN int asn1PE_H245MaintenanceLoopReject (OOCTXT* pctxt, H245MaintenanceLoopReject* pvalue);
+
+EXTERN int asn1PD_H245MaintenanceLoopReject (OOCTXT* pctxt, H245MaintenanceLoopReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeTableEntry_dataType                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CommunicationModeTableEntry_dataType_videoData 1
+#define T_H245CommunicationModeTableEntry_dataType_audioData 2
+#define T_H245CommunicationModeTableEntry_dataType_data 3
+#define T_H245CommunicationModeTableEntry_dataType_extElem1 4
+
+typedef struct EXTERN H245CommunicationModeTableEntry_dataType {
+   int t;
+   union {
+      /* t = 1 */
+      H245VideoCapability *videoData;
+      /* t = 2 */
+      H245AudioCapability *audioData;
+      /* t = 3 */
+      H245DataApplicationCapability *data;
+      /* t = 4 */
+   } u;
+} H245CommunicationModeTableEntry_dataType;
+
+EXTERN int asn1PE_H245CommunicationModeTableEntry_dataType (OOCTXT* pctxt, H245CommunicationModeTableEntry_dataType* pvalue);
+
+EXTERN int asn1PD_H245CommunicationModeTableEntry_dataType (OOCTXT* pctxt, H245CommunicationModeTableEntry_dataType* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeTableEntry                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CommunicationModeTableEntry {
+   struct {
+      unsigned nonStandardPresent : 1;
+      unsigned associatedSessionIDPresent : 1;
+      unsigned terminalLabelPresent : 1;
+      unsigned mediaChannelPresent : 1;
+      unsigned mediaGuaranteedDeliveryPresent : 1;
+      unsigned mediaControlChannelPresent : 1;
+      unsigned mediaControlGuaranteedDeliveryPresent : 1;
+      unsigned redundancyEncodingPresent : 1;
+      unsigned sessionDependencyPresent : 1;
+      unsigned destinationPresent : 1;
+   } m;
+   H245_SeqOfH245NonStandardParameter nonStandard;
+   ASN1UINT8 sessionID;
+   ASN1UINT8 associatedSessionID;
+   H245TerminalLabel terminalLabel;
+   ASN1BMPString sessionDescription;
+   H245CommunicationModeTableEntry_dataType dataType;
+   H245TransportAddress mediaChannel;
+   ASN1BOOL mediaGuaranteedDelivery;
+   H245TransportAddress mediaControlChannel;
+   ASN1BOOL mediaControlGuaranteedDelivery;
+   H245RedundancyEncoding redundancyEncoding;
+   ASN1UINT8 sessionDependency;
+   H245TerminalLabel destination;
+} H245CommunicationModeTableEntry;
+
+EXTERN int asn1PE_H245CommunicationModeTableEntry (OOCTXT* pctxt, H245CommunicationModeTableEntry* pvalue);
+
+EXTERN int asn1PD_H245CommunicationModeTableEntry (OOCTXT* pctxt, H245CommunicationModeTableEntry* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeResponse_communicationModeTable          */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245CommunicationModeTableEntry */
+typedef DList H245CommunicationModeResponse_communicationModeTable;
+
+EXTERN int asn1PE_H245CommunicationModeResponse_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeResponse_communicationModeTable* pvalue);
+
+EXTERN int asn1PD_H245CommunicationModeResponse_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeResponse_communicationModeTable* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeResponse                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CommunicationModeResponse_communicationModeTable 1
+#define T_H245CommunicationModeResponse_extElem1 2
+
+typedef struct EXTERN H245CommunicationModeResponse {
+   int t;
+   union {
+      /* t = 1 */
+      H245CommunicationModeResponse_communicationModeTable *communicationModeTable;
+      /* t = 2 */
+   } u;
+} H245CommunicationModeResponse;
+
+EXTERN int asn1PE_H245CommunicationModeResponse (OOCTXT* pctxt, H245CommunicationModeResponse* pvalue);
+
+EXTERN int asn1PD_H245CommunicationModeResponse (OOCTXT* pctxt, H245CommunicationModeResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalID                                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TerminalID {
+   ASN1UINT numocts;
+   ASN1OCTET data[128];
+} H245TerminalID;
+
+EXTERN int asn1PE_H245TerminalID (OOCTXT* pctxt, H245TerminalID* pvalue);
+
+EXTERN int asn1PD_H245TerminalID (OOCTXT* pctxt, H245TerminalID* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_mCTerminalIDResponse                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceResponse_mCTerminalIDResponse {
+   H245TerminalLabel terminalLabel;
+   H245TerminalID terminalID;
+} H245ConferenceResponse_mCTerminalIDResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_mCTerminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_mCTerminalIDResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_mCTerminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_mCTerminalIDResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalIDResponse                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceResponse_terminalIDResponse {
+   H245TerminalLabel terminalLabel;
+   H245TerminalID terminalID;
+} H245ConferenceResponse_terminalIDResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_terminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalIDResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_terminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalIDResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceID                                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceID {
+   ASN1UINT numocts;
+   ASN1OCTET data[32];
+} H245ConferenceID;
+
+EXTERN int asn1PE_H245ConferenceID (OOCTXT* pctxt, H245ConferenceID* pvalue);
+
+EXTERN int asn1PD_H245ConferenceID (OOCTXT* pctxt, H245ConferenceID* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_conferenceIDResponse                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceResponse_conferenceIDResponse {
+   H245TerminalLabel terminalLabel;
+   H245ConferenceID conferenceID;
+} H245ConferenceResponse_conferenceIDResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_conferenceIDResponse (OOCTXT* pctxt, H245ConferenceResponse_conferenceIDResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_conferenceIDResponse (OOCTXT* pctxt, H245ConferenceResponse_conferenceIDResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  Password                                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245Password {
+   ASN1UINT numocts;
+   ASN1OCTET data[32];
+} H245Password;
+
+EXTERN int asn1PE_H245Password (OOCTXT* pctxt, H245Password* pvalue);
+
+EXTERN int asn1PD_H245Password (OOCTXT* pctxt, H245Password* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_passwordResponse                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceResponse_passwordResponse {
+   H245TerminalLabel terminalLabel;
+   H245Password password;
+} H245ConferenceResponse_passwordResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_passwordResponse (OOCTXT* pctxt, H245ConferenceResponse_passwordResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_passwordResponse (OOCTXT* pctxt, H245ConferenceResponse_passwordResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalListResponse                   */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245TerminalLabel */
+typedef DList H245ConferenceResponse_terminalListResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_terminalListResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalListResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_terminalListResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalListResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_makeMeChairResponse                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ConferenceResponse_makeMeChairResponse_grantedChairToken 1
+#define T_H245ConferenceResponse_makeMeChairResponse_deniedChairToken 2
+#define T_H245ConferenceResponse_makeMeChairResponse_extElem1 3
+
+typedef struct EXTERN H245ConferenceResponse_makeMeChairResponse {
+   int t;
+} H245ConferenceResponse_makeMeChairResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_makeMeChairResponse (OOCTXT* pctxt, H245ConferenceResponse_makeMeChairResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_makeMeChairResponse (OOCTXT* pctxt, H245ConferenceResponse_makeMeChairResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_extensionAddressResponse               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceResponse_extensionAddressResponse {
+   H245TerminalID extensionAddress;
+} H245ConferenceResponse_extensionAddressResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_extensionAddressResponse (OOCTXT* pctxt, H245ConferenceResponse_extensionAddressResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_extensionAddressResponse (OOCTXT* pctxt, H245ConferenceResponse_extensionAddressResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_chairTokenOwnerResponse                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceResponse_chairTokenOwnerResponse {
+   H245TerminalLabel terminalLabel;
+   H245TerminalID terminalID;
+} H245ConferenceResponse_chairTokenOwnerResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_chairTokenOwnerResponse (OOCTXT* pctxt, H245ConferenceResponse_chairTokenOwnerResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_chairTokenOwnerResponse (OOCTXT* pctxt, H245ConferenceResponse_chairTokenOwnerResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalCertificateResponse            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245ConferenceResponse_terminalCertificateResponse {
+   struct {
+      unsigned terminalLabelPresent : 1;
+      unsigned certificateResponsePresent : 1;
+   } m;
+   H245TerminalLabel terminalLabel;
+   ASN1DynOctStr certificateResponse;
+} H245ConferenceResponse_terminalCertificateResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_terminalCertificateResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalCertificateResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_terminalCertificateResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalCertificateResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_broadcastMyLogicalChannelResponse      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ConferenceResponse_broadcastMyLogicalChannelResponse_grantedBroadcastMyLogicalChannel 1
+#define T_H245ConferenceResponse_broadcastMyLogicalChannelResponse_deniedBroadcastMyLogicalChannel 2
+#define T_H245ConferenceResponse_broadcastMyLogicalChannelResponse_extElem1 3
+
+typedef struct EXTERN H245ConferenceResponse_broadcastMyLogicalChannelResponse {
+   int t;
+} H245ConferenceResponse_broadcastMyLogicalChannelResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_broadcastMyLogicalChannelResponse (OOCTXT* pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_broadcastMyLogicalChannelResponse (OOCTXT* pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_makeTerminalBroadcasterResponse        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ConferenceResponse_makeTerminalBroadcasterResponse_grantedMakeTerminalBroadcaster 1
+#define T_H245ConferenceResponse_makeTerminalBroadcasterResponse_deniedMakeTerminalBroadcaster 2
+#define T_H245ConferenceResponse_makeTerminalBroadcasterResponse_extElem1 3
+
+typedef struct EXTERN H245ConferenceResponse_makeTerminalBroadcasterResponse {
+   int t;
+} H245ConferenceResponse_makeTerminalBroadcasterResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_makeTerminalBroadcasterResponse (OOCTXT* pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_makeTerminalBroadcasterResponse (OOCTXT* pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_sendThisSourceResponse                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ConferenceResponse_sendThisSourceResponse_grantedSendThisSource 1
+#define T_H245ConferenceResponse_sendThisSourceResponse_deniedSendThisSource 2
+#define T_H245ConferenceResponse_sendThisSourceResponse_extElem1 3
+
+typedef struct EXTERN H245ConferenceResponse_sendThisSourceResponse {
+   int t;
+} H245ConferenceResponse_sendThisSourceResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse_sendThisSourceResponse (OOCTXT* pctxt, H245ConferenceResponse_sendThisSourceResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse_sendThisSourceResponse (OOCTXT* pctxt, H245ConferenceResponse_sendThisSourceResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalInformation                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TerminalInformation {
+   H245TerminalLabel terminalLabel;
+   H245TerminalID terminalID;
+} H245TerminalInformation;
+
+EXTERN int asn1PE_H245TerminalInformation (OOCTXT* pctxt, H245TerminalInformation* pvalue);
+
+EXTERN int asn1PD_H245TerminalInformation (OOCTXT* pctxt, H245TerminalInformation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245TerminalInformation                             */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245TerminalInformation */
+typedef DList H245_SeqOfH245TerminalInformation;
+
+EXTERN int asn1PE_H245_SeqOfH245TerminalInformation (OOCTXT* pctxt, H245_SeqOfH245TerminalInformation* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245TerminalInformation (OOCTXT* pctxt, H245_SeqOfH245TerminalInformation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestAllTerminalIDsResponse                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestAllTerminalIDsResponse {
+   H245_SeqOfH245TerminalInformation terminalInformation;
+} H245RequestAllTerminalIDsResponse;
+
+EXTERN int asn1PE_H245RequestAllTerminalIDsResponse (OOCTXT* pctxt, H245RequestAllTerminalIDsResponse* pvalue);
+
+EXTERN int asn1PD_H245RequestAllTerminalIDsResponse (OOCTXT* pctxt, H245RequestAllTerminalIDsResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCResponse_reject                                   */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RemoteMCResponse_reject_unspecified 1
+#define T_H245RemoteMCResponse_reject_functionNotSupported 2
+#define T_H245RemoteMCResponse_reject_extElem1 3
+
+typedef struct EXTERN H245RemoteMCResponse_reject {
+   int t;
+} H245RemoteMCResponse_reject;
+
+EXTERN int asn1PE_H245RemoteMCResponse_reject (OOCTXT* pctxt, H245RemoteMCResponse_reject* pvalue);
+
+EXTERN int asn1PD_H245RemoteMCResponse_reject (OOCTXT* pctxt, H245RemoteMCResponse_reject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCResponse                                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245RemoteMCResponse_accept   1
+#define T_H245RemoteMCResponse_reject   2
+#define T_H245RemoteMCResponse_extElem1 3
+
+typedef struct EXTERN H245RemoteMCResponse {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245RemoteMCResponse_reject *reject;
+      /* t = 3 */
+   } u;
+} H245RemoteMCResponse;
+
+EXTERN int asn1PE_H245RemoteMCResponse (OOCTXT* pctxt, H245RemoteMCResponse* pvalue);
+
+EXTERN int asn1PD_H245RemoteMCResponse (OOCTXT* pctxt, H245RemoteMCResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse                                        */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ConferenceResponse_mCTerminalIDResponse 1
+#define T_H245ConferenceResponse_terminalIDResponse 2
+#define T_H245ConferenceResponse_conferenceIDResponse 3
+#define T_H245ConferenceResponse_passwordResponse 4
+#define T_H245ConferenceResponse_terminalListResponse 5
+#define T_H245ConferenceResponse_videoCommandReject 6
+#define T_H245ConferenceResponse_terminalDropReject 7
+#define T_H245ConferenceResponse_makeMeChairResponse 8
+#define T_H245ConferenceResponse_extensionAddressResponse 9
+#define T_H245ConferenceResponse_chairTokenOwnerResponse 10
+#define T_H245ConferenceResponse_terminalCertificateResponse 11
+#define T_H245ConferenceResponse_broadcastMyLogicalChannelResponse 12
+#define T_H245ConferenceResponse_makeTerminalBroadcasterResponse 13
+#define T_H245ConferenceResponse_sendThisSourceResponse 14
+#define T_H245ConferenceResponse_requestAllTerminalIDsResponse 15
+#define T_H245ConferenceResponse_remoteMCResponse 16
+#define T_H245ConferenceResponse_extElem1 17
+
+typedef struct EXTERN H245ConferenceResponse {
+   int t;
+   union {
+      /* t = 1 */
+      H245ConferenceResponse_mCTerminalIDResponse *mCTerminalIDResponse;
+      /* t = 2 */
+      H245ConferenceResponse_terminalIDResponse *terminalIDResponse;
+      /* t = 3 */
+      H245ConferenceResponse_conferenceIDResponse *conferenceIDResponse;
+      /* t = 4 */
+      H245ConferenceResponse_passwordResponse *passwordResponse;
+      /* t = 5 */
+      H245ConferenceResponse_terminalListResponse *terminalListResponse;
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      H245ConferenceResponse_makeMeChairResponse *makeMeChairResponse;
+      /* t = 9 */
+      H245ConferenceResponse_extensionAddressResponse *extensionAddressResponse;
+      /* t = 10 */
+      H245ConferenceResponse_chairTokenOwnerResponse *chairTokenOwnerResponse;
+      /* t = 11 */
+      H245ConferenceResponse_terminalCertificateResponse *terminalCertificateResponse;
+      /* t = 12 */
+      H245ConferenceResponse_broadcastMyLogicalChannelResponse *broadcastMyLogicalChannelResponse;
+      /* t = 13 */
+      H245ConferenceResponse_makeTerminalBroadcasterResponse *makeTerminalBroadcasterResponse;
+      /* t = 14 */
+      H245ConferenceResponse_sendThisSourceResponse *sendThisSourceResponse;
+      /* t = 15 */
+      H245RequestAllTerminalIDsResponse *requestAllTerminalIDsResponse;
+      /* t = 16 */
+      H245RemoteMCResponse *remoteMCResponse;
+      /* t = 17 */
+   } u;
+} H245ConferenceResponse;
+
+EXTERN int asn1PE_H245ConferenceResponse (OOCTXT* pctxt, H245ConferenceResponse* pvalue);
+
+EXTERN int asn1PD_H245ConferenceResponse (OOCTXT* pctxt, H245ConferenceResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_callInformation                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkResponse_callInformation {
+   H245DialingInformation dialingInformation;
+   ASN1UINT callAssociationNumber;
+} H245MultilinkResponse_callInformation;
+
+EXTERN int asn1PE_H245MultilinkResponse_callInformation (OOCTXT* pctxt, H245MultilinkResponse_callInformation* pvalue);
+
+EXTERN int asn1PD_H245MultilinkResponse_callInformation (OOCTXT* pctxt, H245MultilinkResponse_callInformation* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection_responseCode_rejected     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultilinkResponse_addConnection_responseCode_rejected_connectionsNotAvailable 1
+#define T_H245MultilinkResponse_addConnection_responseCode_rejected_userRejected 2
+#define T_H245MultilinkResponse_addConnection_responseCode_rejected_extElem1 3
+
+typedef struct EXTERN H245MultilinkResponse_addConnection_responseCode_rejected {
+   int t;
+} H245MultilinkResponse_addConnection_responseCode_rejected;
+
+EXTERN int asn1PE_H245MultilinkResponse_addConnection_responseCode_rejected (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode_rejected* pvalue);
+
+EXTERN int asn1PD_H245MultilinkResponse_addConnection_responseCode_rejected (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode_rejected* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection_responseCode              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultilinkResponse_addConnection_responseCode_accepted 1
+#define T_H245MultilinkResponse_addConnection_responseCode_rejected 2
+#define T_H245MultilinkResponse_addConnection_responseCode_extElem1 3
+
+typedef struct EXTERN H245MultilinkResponse_addConnection_responseCode {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      H245MultilinkResponse_addConnection_responseCode_rejected *rejected;
+      /* t = 3 */
+   } u;
+} H245MultilinkResponse_addConnection_responseCode;
+
+EXTERN int asn1PE_H245MultilinkResponse_addConnection_responseCode (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode* pvalue);
+
+EXTERN int asn1PD_H245MultilinkResponse_addConnection_responseCode (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkResponse_addConnection {
+   H245SequenceNumber sequenceNumber;
+   H245MultilinkResponse_addConnection_responseCode responseCode;
+} H245MultilinkResponse_addConnection;
+
+EXTERN int asn1PE_H245MultilinkResponse_addConnection (OOCTXT* pctxt, H245MultilinkResponse_addConnection* pvalue);
+
+EXTERN int asn1PD_H245MultilinkResponse_addConnection (OOCTXT* pctxt, H245MultilinkResponse_addConnection* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_removeConnection                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkResponse_removeConnection {
+   H245ConnectionIdentifier connectionIdentifier;
+} H245MultilinkResponse_removeConnection;
+
+EXTERN int asn1PE_H245MultilinkResponse_removeConnection (OOCTXT* pctxt, H245MultilinkResponse_removeConnection* pvalue);
+
+EXTERN int asn1PD_H245MultilinkResponse_removeConnection (OOCTXT* pctxt, H245MultilinkResponse_removeConnection* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_maximumHeaderInterval                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkResponse_maximumHeaderInterval {
+   ASN1USINT currentInterval;
+} H245MultilinkResponse_maximumHeaderInterval;
+
+EXTERN int asn1PE_H245MultilinkResponse_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkResponse_maximumHeaderInterval* pvalue);
+
+EXTERN int asn1PD_H245MultilinkResponse_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkResponse_maximumHeaderInterval* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultilinkResponse_nonStandard 1
+#define T_H245MultilinkResponse_callInformation 2
+#define T_H245MultilinkResponse_addConnection 3
+#define T_H245MultilinkResponse_removeConnection 4
+#define T_H245MultilinkResponse_maximumHeaderInterval 5
+#define T_H245MultilinkResponse_extElem1 6
+
+typedef struct EXTERN H245MultilinkResponse {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      H245MultilinkResponse_callInformation *callInformation;
+      /* t = 3 */
+      H245MultilinkResponse_addConnection *addConnection;
+      /* t = 4 */
+      H245MultilinkResponse_removeConnection *removeConnection;
+      /* t = 5 */
+      H245MultilinkResponse_maximumHeaderInterval *maximumHeaderInterval;
+      /* t = 6 */
+   } u;
+} H245MultilinkResponse;
+
+EXTERN int asn1PE_H245MultilinkResponse (OOCTXT* pctxt, H245MultilinkResponse* pvalue);
+
+EXTERN int asn1PD_H245MultilinkResponse (OOCTXT* pctxt, H245MultilinkResponse* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateAcknowledge                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245LogicalChannelRateAcknowledge {
+   H245SequenceNumber sequenceNumber;
+   H245LogicalChannelNumber logicalChannelNumber;
+   H245MaximumBitRate maximumBitRate;
+} H245LogicalChannelRateAcknowledge;
+
+EXTERN int asn1PE_H245LogicalChannelRateAcknowledge (OOCTXT* pctxt, H245LogicalChannelRateAcknowledge* pvalue);
+
+EXTERN int asn1PD_H245LogicalChannelRateAcknowledge (OOCTXT* pctxt, H245LogicalChannelRateAcknowledge* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRejectReason                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245LogicalChannelRateRejectReason_undefinedReason 1
+#define T_H245LogicalChannelRateRejectReason_insufficientResources 2
+#define T_H245LogicalChannelRateRejectReason_extElem1 3
+
+typedef struct EXTERN H245LogicalChannelRateRejectReason {
+   int t;
+} H245LogicalChannelRateRejectReason;
+
+EXTERN int asn1PE_H245LogicalChannelRateRejectReason (OOCTXT* pctxt, H245LogicalChannelRateRejectReason* pvalue);
+
+EXTERN int asn1PD_H245LogicalChannelRateRejectReason (OOCTXT* pctxt, H245LogicalChannelRateRejectReason* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateReject                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245LogicalChannelRateReject {
+   struct {
+      unsigned currentMaximumBitRatePresent : 1;
+   } m;
+   H245SequenceNumber sequenceNumber;
+   H245LogicalChannelNumber logicalChannelNumber;
+   H245LogicalChannelRateRejectReason rejectReason;
+   H245MaximumBitRate currentMaximumBitRate;
+} H245LogicalChannelRateReject;
+
+EXTERN int asn1PE_H245LogicalChannelRateReject (OOCTXT* pctxt, H245LogicalChannelRateReject* pvalue);
+
+EXTERN int asn1PD_H245LogicalChannelRateReject (OOCTXT* pctxt, H245LogicalChannelRateReject* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ResponseMessage                                           */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ResponseMessage_nonStandard 1
+#define T_H245ResponseMessage_masterSlaveDeterminationAck 2
+#define T_H245ResponseMessage_masterSlaveDeterminationReject 3
+#define T_H245ResponseMessage_terminalCapabilitySetAck 4
+#define T_H245ResponseMessage_terminalCapabilitySetReject 5
+#define T_H245ResponseMessage_openLogicalChannelAck 6
+#define T_H245ResponseMessage_openLogicalChannelReject 7
+#define T_H245ResponseMessage_closeLogicalChannelAck 8
+#define T_H245ResponseMessage_requestChannelCloseAck 9
+#define T_H245ResponseMessage_requestChannelCloseReject 10
+#define T_H245ResponseMessage_multiplexEntrySendAck 11
+#define T_H245ResponseMessage_multiplexEntrySendReject 12
+#define T_H245ResponseMessage_requestMultiplexEntryAck 13
+#define T_H245ResponseMessage_requestMultiplexEntryReject 14
+#define T_H245ResponseMessage_requestModeAck 15
+#define T_H245ResponseMessage_requestModeReject 16
+#define T_H245ResponseMessage_roundTripDelayResponse 17
+#define T_H245ResponseMessage_maintenanceLoopAck 18
+#define T_H245ResponseMessage_maintenanceLoopReject 19
+#define T_H245ResponseMessage_communicationModeResponse 20
+#define T_H245ResponseMessage_conferenceResponse 21
+#define T_H245ResponseMessage_multilinkResponse 22
+#define T_H245ResponseMessage_logicalChannelRateAcknowledge 23
+#define T_H245ResponseMessage_logicalChannelRateReject 24
+#define T_H245ResponseMessage_extElem1  25
+
+typedef struct EXTERN H245ResponseMessage {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      H245MasterSlaveDeterminationAck *masterSlaveDeterminationAck;
+      /* t = 3 */
+      H245MasterSlaveDeterminationReject *masterSlaveDeterminationReject;
+      /* t = 4 */
+      H245TerminalCapabilitySetAck *terminalCapabilitySetAck;
+      /* t = 5 */
+      H245TerminalCapabilitySetReject *terminalCapabilitySetReject;
+      /* t = 6 */
+      H245OpenLogicalChannelAck *openLogicalChannelAck;
+      /* t = 7 */
+      H245OpenLogicalChannelReject *openLogicalChannelReject;
+      /* t = 8 */
+      H245CloseLogicalChannelAck *closeLogicalChannelAck;
+      /* t = 9 */
+      H245RequestChannelCloseAck *requestChannelCloseAck;
+      /* t = 10 */
+      H245RequestChannelCloseReject *requestChannelCloseReject;
+      /* t = 11 */
+      H245MultiplexEntrySendAck *multiplexEntrySendAck;
+      /* t = 12 */
+      H245MultiplexEntrySendReject *multiplexEntrySendReject;
+      /* t = 13 */
+      H245RequestMultiplexEntryAck *requestMultiplexEntryAck;
+      /* t = 14 */
+      H245RequestMultiplexEntryReject *requestMultiplexEntryReject;
+      /* t = 15 */
+      H245RequestModeAck *requestModeAck;
+      /* t = 16 */
+      H245RequestModeReject *requestModeReject;
+      /* t = 17 */
+      H245RoundTripDelayResponse *roundTripDelayResponse;
+      /* t = 18 */
+      H245MaintenanceLoopAck *maintenanceLoopAck;
+      /* t = 19 */
+      H245MaintenanceLoopReject *maintenanceLoopReject;
+      /* t = 20 */
+      H245CommunicationModeResponse *communicationModeResponse;
+      /* t = 21 */
+      H245ConferenceResponse *conferenceResponse;
+      /* t = 22 */
+      H245MultilinkResponse *multilinkResponse;
+      /* t = 23 */
+      H245LogicalChannelRateAcknowledge *logicalChannelRateAcknowledge;
+      /* t = 24 */
+      H245LogicalChannelRateReject *logicalChannelRateReject;
+      /* t = 25 */
+   } u;
+} H245ResponseMessage;
+
+EXTERN int asn1PE_H245ResponseMessage (OOCTXT* pctxt, H245ResponseMessage* pvalue);
+
+EXTERN int asn1PD_H245ResponseMessage (OOCTXT* pctxt, H245ResponseMessage* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopOffCommand                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MaintenanceLoopOffCommand {
+   ASN1OCTET __dummy__;
+} H245MaintenanceLoopOffCommand;
+
+EXTERN int asn1PE_H245MaintenanceLoopOffCommand (OOCTXT* pctxt, H245MaintenanceLoopOffCommand* pvalue);
+
+EXTERN int asn1PD_H245MaintenanceLoopOffCommand (OOCTXT* pctxt, H245MaintenanceLoopOffCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest_capabilityTabl  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers {
+   ASN1UINT n;
+   H245CapabilityTableEntryNumber *elem;
+} H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers;
+
+EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers* pvalue);
+
+EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest_capabilityDesc  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers {
+   ASN1UINT n;
+   H245CapabilityDescriptorNumber elem[256];
+} H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers;
+
+EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers* pvalue);
+
+EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245SendTerminalCapabilitySet_specificRequest {
+   struct {
+      unsigned capabilityTableEntryNumbersPresent : 1;
+      unsigned capabilityDescriptorNumbersPresent : 1;
+   } m;
+   ASN1BOOL multiplexCapability;
+   H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers capabilityTableEntryNumbers;
+   H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers capabilityDescriptorNumbers;
+} H245SendTerminalCapabilitySet_specificRequest;
+
+EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest* pvalue);
+
+EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245SendTerminalCapabilitySet_specificRequest 1
+#define T_H245SendTerminalCapabilitySet_genericRequest 2
+#define T_H245SendTerminalCapabilitySet_extElem1 3
+
+typedef struct EXTERN H245SendTerminalCapabilitySet {
+   int t;
+   union {
+      /* t = 1 */
+      H245SendTerminalCapabilitySet_specificRequest *specificRequest;
+      /* t = 2 */
+      /* t = 3 */
+   } u;
+} H245SendTerminalCapabilitySet;
+
+EXTERN int asn1PE_H245SendTerminalCapabilitySet (OOCTXT* pctxt, H245SendTerminalCapabilitySet* pvalue);
+
+EXTERN int asn1PD_H245SendTerminalCapabilitySet (OOCTXT* pctxt, H245SendTerminalCapabilitySet* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCommand_encryptionAlgorithmID                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245EncryptionCommand_encryptionAlgorithmID {
+   H245SequenceNumber h233AlgorithmIdentifier;
+   H245NonStandardParameter associatedAlgorithm;
+} H245EncryptionCommand_encryptionAlgorithmID;
+
+EXTERN int asn1PE_H245EncryptionCommand_encryptionAlgorithmID (OOCTXT* pctxt, H245EncryptionCommand_encryptionAlgorithmID* pvalue);
+
+EXTERN int asn1PD_H245EncryptionCommand_encryptionAlgorithmID (OOCTXT* pctxt, H245EncryptionCommand_encryptionAlgorithmID* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245EncryptionCommand_encryptionSE 1
+#define T_H245EncryptionCommand_encryptionIVRequest 2
+#define T_H245EncryptionCommand_encryptionAlgorithmID 3
+#define T_H245EncryptionCommand_extElem1 4
+
+typedef struct EXTERN H245EncryptionCommand {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1DynOctStr *encryptionSE;
+      /* t = 2 */
+      /* t = 3 */
+      H245EncryptionCommand_encryptionAlgorithmID *encryptionAlgorithmID;
+      /* t = 4 */
+   } u;
+} H245EncryptionCommand;
+
+EXTERN int asn1PE_H245EncryptionCommand (OOCTXT* pctxt, H245EncryptionCommand* pvalue);
+
+EXTERN int asn1PD_H245EncryptionCommand (OOCTXT* pctxt, H245EncryptionCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand_scope                                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FlowControlCommand_scope_logicalChannelNumber 1
+#define T_H245FlowControlCommand_scope_resourceID 2
+#define T_H245FlowControlCommand_scope_wholeMultiplex 3
+
+typedef struct EXTERN H245FlowControlCommand_scope {
+   int t;
+   union {
+      /* t = 1 */
+      H245LogicalChannelNumber logicalChannelNumber;
+      /* t = 2 */
+      ASN1USINT resourceID;
+      /* t = 3 */
+   } u;
+} H245FlowControlCommand_scope;
+
+EXTERN int asn1PE_H245FlowControlCommand_scope (OOCTXT* pctxt, H245FlowControlCommand_scope* pvalue);
+
+EXTERN int asn1PD_H245FlowControlCommand_scope (OOCTXT* pctxt, H245FlowControlCommand_scope* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand_restriction                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FlowControlCommand_restriction_maximumBitRate 1
+#define T_H245FlowControlCommand_restriction_noRestriction 2
+
+typedef struct EXTERN H245FlowControlCommand_restriction {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1UINT maximumBitRate;
+      /* t = 2 */
+   } u;
+} H245FlowControlCommand_restriction;
+
+EXTERN int asn1PE_H245FlowControlCommand_restriction (OOCTXT* pctxt, H245FlowControlCommand_restriction* pvalue);
+
+EXTERN int asn1PD_H245FlowControlCommand_restriction (OOCTXT* pctxt, H245FlowControlCommand_restriction* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FlowControlCommand {
+   H245FlowControlCommand_scope scope;
+   H245FlowControlCommand_restriction restriction;
+} H245FlowControlCommand;
+
+EXTERN int asn1PE_H245FlowControlCommand (OOCTXT* pctxt, H245FlowControlCommand* pvalue);
+
+EXTERN int asn1PD_H245FlowControlCommand (OOCTXT* pctxt, H245FlowControlCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand_gstnOptions                             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245EndSessionCommand_gstnOptions_telephonyMode 1
+#define T_H245EndSessionCommand_gstnOptions_v8bis 2
+#define T_H245EndSessionCommand_gstnOptions_v34DSVD 3
+#define T_H245EndSessionCommand_gstnOptions_v34DuplexFAX 4
+#define T_H245EndSessionCommand_gstnOptions_v34H324 5
+#define T_H245EndSessionCommand_gstnOptions_extElem1 6
+
+typedef struct EXTERN H245EndSessionCommand_gstnOptions {
+   int t;
+} H245EndSessionCommand_gstnOptions;
+
+EXTERN int asn1PE_H245EndSessionCommand_gstnOptions (OOCTXT* pctxt, H245EndSessionCommand_gstnOptions* pvalue);
+
+EXTERN int asn1PD_H245EndSessionCommand_gstnOptions (OOCTXT* pctxt, H245EndSessionCommand_gstnOptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand_isdnOptions                             */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245EndSessionCommand_isdnOptions_telephonyMode 1
+#define T_H245EndSessionCommand_isdnOptions_v140 2
+#define T_H245EndSessionCommand_isdnOptions_terminalOnHold 3
+#define T_H245EndSessionCommand_isdnOptions_extElem1 4
+
+typedef struct EXTERN H245EndSessionCommand_isdnOptions {
+   int t;
+} H245EndSessionCommand_isdnOptions;
+
+EXTERN int asn1PE_H245EndSessionCommand_isdnOptions (OOCTXT* pctxt, H245EndSessionCommand_isdnOptions* pvalue);
+
+EXTERN int asn1PD_H245EndSessionCommand_isdnOptions (OOCTXT* pctxt, H245EndSessionCommand_isdnOptions* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245EndSessionCommand_nonStandard 1
+#define T_H245EndSessionCommand_disconnect 2
+#define T_H245EndSessionCommand_gstnOptions 3
+#define T_H245EndSessionCommand_isdnOptions 4
+#define T_H245EndSessionCommand_extElem1 5
+
+typedef struct EXTERN H245EndSessionCommand {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      H245EndSessionCommand_gstnOptions *gstnOptions;
+      /* t = 4 */
+      H245EndSessionCommand_isdnOptions *isdnOptions;
+      /* t = 5 */
+   } u;
+} H245EndSessionCommand;
+
+EXTERN int asn1PE_H245EndSessionCommand (OOCTXT* pctxt, H245EndSessionCommand* pvalue);
+
+EXTERN int asn1PD_H245EndSessionCommand (OOCTXT* pctxt, H245EndSessionCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoFastUpdateGOB              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MiscellaneousCommand_type_videoFastUpdateGOB {
+   ASN1UINT8 firstGOB;
+   ASN1UINT8 numberOfGOBs;
+} H245MiscellaneousCommand_type_videoFastUpdateGOB;
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_videoFastUpdateGOB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_videoFastUpdateGOB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoFastUpdateMB               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MiscellaneousCommand_type_videoFastUpdateMB {
+   struct {
+      unsigned firstGOBPresent : 1;
+      unsigned firstMBPresent : 1;
+   } m;
+   ASN1UINT8 firstGOB;
+   ASN1USINT firstMB;
+   ASN1USINT numberOfMBs;
+} H245MiscellaneousCommand_type_videoFastUpdateMB;
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_videoFastUpdateMB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_videoFastUpdateMB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  KeyProtectionMethod                                       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245KeyProtectionMethod {
+   ASN1BOOL secureChannel;
+   ASN1BOOL sharedSecret;
+   ASN1BOOL certProtectedKey;
+} H245KeyProtectionMethod;
+
+EXTERN int asn1PE_H245KeyProtectionMethod (OOCTXT* pctxt, H245KeyProtectionMethod* pvalue);
+
+EXTERN int asn1PD_H245KeyProtectionMethod (OOCTXT* pctxt, H245KeyProtectionMethod* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionUpdateRequest                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245EncryptionUpdateRequest {
+   struct {
+      unsigned keyProtectionMethodPresent : 1;
+   } m;
+   H245KeyProtectionMethod keyProtectionMethod;
+} H245EncryptionUpdateRequest;
+
+EXTERN int asn1PE_H245EncryptionUpdateRequest (OOCTXT* pctxt, H245EncryptionUpdateRequest* pvalue);
+
+EXTERN int asn1PD_H245EncryptionUpdateRequest (OOCTXT* pctxt, H245EncryptionUpdateRequest* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_progressiveRefinementStart_rep  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_doOneProgression 1
+#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_doContinuousProgressions 2
+#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_doOneIndependentProgression 3
+#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_doContinuousIndependentProgressions 4
+#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_extElem1 5
+
+typedef struct EXTERN H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount {
+   int t;
+} H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount;
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_progressiveRefinementStart      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MiscellaneousCommand_type_progressiveRefinementStart {
+   H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount repeatCount;
+} H245MiscellaneousCommand_type_progressiveRefinementStart;
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoBadMBs                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MiscellaneousCommand_type_videoBadMBs {
+   ASN1USINT firstMB;
+   ASN1USINT numberOfMBs;
+   ASN1USINT temporalReference;
+} H245MiscellaneousCommand_type_videoBadMBs;
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_videoBadMBs (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoBadMBs* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_videoBadMBs (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoBadMBs* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  PictureReference                                          */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245PictureReference_pictureNumber 1
+#define T_H245PictureReference_longTermPictureIndex 2
+#define T_H245PictureReference_extElem1 3
+
+typedef struct EXTERN H245PictureReference {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1USINT pictureNumber;
+      /* t = 2 */
+      ASN1UINT8 longTermPictureIndex;
+      /* t = 3 */
+   } u;
+} H245PictureReference;
+
+EXTERN int asn1PE_H245PictureReference (OOCTXT* pctxt, H245PictureReference* pvalue);
+
+EXTERN int asn1PD_H245PictureReference (OOCTXT* pctxt, H245PictureReference* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245PictureReference                                */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245PictureReference */
+typedef DList H245_SeqOfH245PictureReference;
+
+EXTERN int asn1PE_H245_SeqOfH245PictureReference (OOCTXT* pctxt, H245_SeqOfH245PictureReference* pvalue);
+
+EXTERN int asn1PD_H245_SeqOfH245PictureReference (OOCTXT* pctxt, H245_SeqOfH245PictureReference* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_lostPartialPicture              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MiscellaneousCommand_type_lostPartialPicture {
+   H245PictureReference pictureReference;
+   ASN1USINT firstMB;
+   ASN1USINT numberOfMBs;
+} H245MiscellaneousCommand_type_lostPartialPicture;
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_lostPartialPicture (OOCTXT* pctxt, H245MiscellaneousCommand_type_lostPartialPicture* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_lostPartialPicture (OOCTXT* pctxt, H245MiscellaneousCommand_type_lostPartialPicture* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MiscellaneousCommand_type_equaliseDelay 1
+#define T_H245MiscellaneousCommand_type_zeroDelay 2
+#define T_H245MiscellaneousCommand_type_multipointModeCommand 3
+#define T_H245MiscellaneousCommand_type_cancelMultipointModeCommand 4
+#define T_H245MiscellaneousCommand_type_videoFreezePicture 5
+#define T_H245MiscellaneousCommand_type_videoFastUpdatePicture 6
+#define T_H245MiscellaneousCommand_type_videoFastUpdateGOB 7
+#define T_H245MiscellaneousCommand_type_videoTemporalSpatialTradeOff 8
+#define T_H245MiscellaneousCommand_type_videoSendSyncEveryGOB 9
+#define T_H245MiscellaneousCommand_type_videoSendSyncEveryGOBCancel 10
+#define T_H245MiscellaneousCommand_type_videoFastUpdateMB 11
+#define T_H245MiscellaneousCommand_type_maxH223MUXPDUsize 12
+#define T_H245MiscellaneousCommand_type_encryptionUpdate 13
+#define T_H245MiscellaneousCommand_type_encryptionUpdateRequest 14
+#define T_H245MiscellaneousCommand_type_switchReceiveMediaOff 15
+#define T_H245MiscellaneousCommand_type_switchReceiveMediaOn 16
+#define T_H245MiscellaneousCommand_type_progressiveRefinementStart 17
+#define T_H245MiscellaneousCommand_type_progressiveRefinementAbortOne 18
+#define T_H245MiscellaneousCommand_type_progressiveRefinementAbortContinuous 19
+#define T_H245MiscellaneousCommand_type_videoBadMBs 20
+#define T_H245MiscellaneousCommand_type_lostPicture 21
+#define T_H245MiscellaneousCommand_type_lostPartialPicture 22
+#define T_H245MiscellaneousCommand_type_recoveryReferencePicture 23
+#define T_H245MiscellaneousCommand_type_extElem1 24
+
+typedef struct EXTERN H245MiscellaneousCommand_type {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      H245MiscellaneousCommand_type_videoFastUpdateGOB *videoFastUpdateGOB;
+      /* t = 8 */
+      ASN1UINT8 videoTemporalSpatialTradeOff;
+      /* t = 9 */
+      /* t = 10 */
+      /* t = 11 */
+      H245MiscellaneousCommand_type_videoFastUpdateMB *videoFastUpdateMB;
+      /* t = 12 */
+      ASN1USINT maxH223MUXPDUsize;
+      /* t = 13 */
+      H245EncryptionSync *encryptionUpdate;
+      /* t = 14 */
+      H245EncryptionUpdateRequest *encryptionUpdateRequest;
+      /* t = 15 */
+      /* t = 16 */
+      /* t = 17 */
+      H245MiscellaneousCommand_type_progressiveRefinementStart *progressiveRefinementStart;
+      /* t = 18 */
+      /* t = 19 */
+      /* t = 20 */
+      H245MiscellaneousCommand_type_videoBadMBs *videoBadMBs;
+      /* t = 21 */
+      H245_SeqOfH245PictureReference *lostPicture;
+      /* t = 22 */
+      H245MiscellaneousCommand_type_lostPartialPicture *lostPartialPicture;
+      /* t = 23 */
+      H245_SeqOfH245PictureReference *recoveryReferencePicture;
+      /* t = 24 */
+   } u;
+} H245MiscellaneousCommand_type;
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type (OOCTXT* pctxt, H245MiscellaneousCommand_type* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type (OOCTXT* pctxt, H245MiscellaneousCommand_type* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MiscellaneousCommand {
+   H245LogicalChannelNumber logicalChannelNumber;
+   H245MiscellaneousCommand_type type;
+} H245MiscellaneousCommand;
+
+EXTERN int asn1PE_H245MiscellaneousCommand (OOCTXT* pctxt, H245MiscellaneousCommand* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousCommand (OOCTXT* pctxt, H245MiscellaneousCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeCommand_communicationModeTable           */
+/*                                                            */
+/**************************************************************/
+
+/* List of H245CommunicationModeTableEntry */
+typedef DList H245CommunicationModeCommand_communicationModeTable;
+
+EXTERN int asn1PE_H245CommunicationModeCommand_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeCommand_communicationModeTable* pvalue);
+
+EXTERN int asn1PD_H245CommunicationModeCommand_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeCommand_communicationModeTable* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeCommand                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245CommunicationModeCommand {
+   H245CommunicationModeCommand_communicationModeTable communicationModeTable;
+} H245CommunicationModeCommand;
+
+EXTERN int asn1PE_H245CommunicationModeCommand (OOCTXT* pctxt, H245CommunicationModeCommand* pvalue);
+
+EXTERN int asn1PD_H245CommunicationModeCommand (OOCTXT* pctxt, H245CommunicationModeCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SubstituteConferenceIDCommand_conferenceIdentifier        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245SubstituteConferenceIDCommand_conferenceIdentifier {
+   ASN1UINT numocts;
+   ASN1OCTET data[16];
+} H245SubstituteConferenceIDCommand_conferenceIdentifier;
+
+EXTERN int asn1PE_H245SubstituteConferenceIDCommand_conferenceIdentifier (OOCTXT* pctxt, H245SubstituteConferenceIDCommand_conferenceIdentifier* pvalue);
+
+EXTERN int asn1PD_H245SubstituteConferenceIDCommand_conferenceIdentifier (OOCTXT* pctxt, H245SubstituteConferenceIDCommand_conferenceIdentifier* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  SubstituteConferenceIDCommand                             */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245SubstituteConferenceIDCommand {
+   H245SubstituteConferenceIDCommand_conferenceIdentifier conferenceIdentifier;
+} H245SubstituteConferenceIDCommand;
+
+EXTERN int asn1PE_H245SubstituteConferenceIDCommand (OOCTXT* pctxt, H245SubstituteConferenceIDCommand* pvalue);
+
+EXTERN int asn1PD_H245SubstituteConferenceIDCommand (OOCTXT* pctxt, H245SubstituteConferenceIDCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ConferenceCommand_broadcastMyLogicalChannel 1
+#define T_H245ConferenceCommand_cancelBroadcastMyLogicalChannel 2
+#define T_H245ConferenceCommand_makeTerminalBroadcaster 3
+#define T_H245ConferenceCommand_cancelMakeTerminalBroadcaster 4
+#define T_H245ConferenceCommand_sendThisSource 5
+#define T_H245ConferenceCommand_cancelSendThisSource 6
+#define T_H245ConferenceCommand_dropConference 7
+#define T_H245ConferenceCommand_substituteConferenceIDCommand 8
+#define T_H245ConferenceCommand_extElem1 9
+
+typedef struct EXTERN H245ConferenceCommand {
+   int t;
+   union {
+      /* t = 1 */
+      H245LogicalChannelNumber broadcastMyLogicalChannel;
+      /* t = 2 */
+      H245LogicalChannelNumber cancelBroadcastMyLogicalChannel;
+      /* t = 3 */
+      H245TerminalLabel *makeTerminalBroadcaster;
+      /* t = 4 */
+      /* t = 5 */
+      H245TerminalLabel *sendThisSource;
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      H245SubstituteConferenceIDCommand *substituteConferenceIDCommand;
+      /* t = 9 */
+   } u;
+} H245ConferenceCommand;
+
+EXTERN int asn1PE_H245ConferenceCommand (OOCTXT* pctxt, H245ConferenceCommand* pvalue);
+
+EXTERN int asn1PD_H245ConferenceCommand (OOCTXT* pctxt, H245ConferenceCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration_h223ModeChange               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223MultiplexReconfiguration_h223ModeChange_toLevel0 1
+#define T_H245H223MultiplexReconfiguration_h223ModeChange_toLevel1 2
+#define T_H245H223MultiplexReconfiguration_h223ModeChange_toLevel2 3
+#define T_H245H223MultiplexReconfiguration_h223ModeChange_toLevel2withOptionalHeader 4
+#define T_H245H223MultiplexReconfiguration_h223ModeChange_extElem1 5
+
+typedef struct EXTERN H245H223MultiplexReconfiguration_h223ModeChange {
+   int t;
+} H245H223MultiplexReconfiguration_h223ModeChange;
+
+EXTERN int asn1PE_H245H223MultiplexReconfiguration_h223ModeChange (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223ModeChange* pvalue);
+
+EXTERN int asn1PD_H245H223MultiplexReconfiguration_h223ModeChange (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223ModeChange* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration_h223AnnexADoubleFlag         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag_start 1
+#define T_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag_stop 2
+#define T_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag_extElem1 3
+
+typedef struct EXTERN H245H223MultiplexReconfiguration_h223AnnexADoubleFlag {
+   int t;
+} H245H223MultiplexReconfiguration_h223AnnexADoubleFlag;
+
+EXTERN int asn1PE_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag* pvalue);
+
+EXTERN int asn1PD_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245H223MultiplexReconfiguration_h223ModeChange 1
+#define T_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag 2
+#define T_H245H223MultiplexReconfiguration_extElem1 3
+
+typedef struct EXTERN H245H223MultiplexReconfiguration {
+   int t;
+   union {
+      /* t = 1 */
+      H245H223MultiplexReconfiguration_h223ModeChange *h223ModeChange;
+      /* t = 2 */
+      H245H223MultiplexReconfiguration_h223AnnexADoubleFlag *h223AnnexADoubleFlag;
+      /* t = 3 */
+   } u;
+} H245H223MultiplexReconfiguration;
+
+EXTERN int asn1PE_H245H223MultiplexReconfiguration (OOCTXT* pctxt, H245H223MultiplexReconfiguration* pvalue);
+
+EXTERN int asn1PD_H245H223MultiplexReconfiguration (OOCTXT* pctxt, H245H223MultiplexReconfiguration* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1_clockRecovery                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCCommand_aal_aal1_clockRecovery_nullClockRecovery 1
+#define T_H245NewATMVCCommand_aal_aal1_clockRecovery_srtsClockRecovery 2
+#define T_H245NewATMVCCommand_aal_aal1_clockRecovery_adaptiveClockRecovery 3
+#define T_H245NewATMVCCommand_aal_aal1_clockRecovery_extElem1 4
+
+typedef struct EXTERN H245NewATMVCCommand_aal_aal1_clockRecovery {
+   int t;
+} H245NewATMVCCommand_aal_aal1_clockRecovery;
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_clockRecovery* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_clockRecovery* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1_errorCorrection                  */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_nullErrorCorrection 1
+#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_longInterleaver 2
+#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_shortInterleaver 3
+#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_errorCorrectionOnly 4
+#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_extElem1 5
+
+typedef struct EXTERN H245NewATMVCCommand_aal_aal1_errorCorrection {
+   int t;
+} H245NewATMVCCommand_aal_aal1_errorCorrection;
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_errorCorrection* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_errorCorrection* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NewATMVCCommand_aal_aal1 {
+   H245NewATMVCCommand_aal_aal1_clockRecovery clockRecovery;
+   H245NewATMVCCommand_aal_aal1_errorCorrection errorCorrection;
+   ASN1BOOL structuredDataTransfer;
+   ASN1BOOL partiallyFilledCells;
+} H245NewATMVCCommand_aal_aal1;
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal5                                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NewATMVCCommand_aal_aal5 {
+   ASN1USINT forwardMaximumSDUSize;
+   ASN1USINT backwardMaximumSDUSize;
+} H245NewATMVCCommand_aal_aal5;
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal_aal5 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal5* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal_aal5 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal5* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCCommand_aal_aal1  1
+#define T_H245NewATMVCCommand_aal_aal5  2
+#define T_H245NewATMVCCommand_aal_extElem1 3
+
+typedef struct EXTERN H245NewATMVCCommand_aal {
+   int t;
+   union {
+      /* t = 1 */
+      H245NewATMVCCommand_aal_aal1 *aal1;
+      /* t = 2 */
+      H245NewATMVCCommand_aal_aal5 *aal5;
+      /* t = 3 */
+   } u;
+} H245NewATMVCCommand_aal;
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal (OOCTXT* pctxt, H245NewATMVCCommand_aal* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal (OOCTXT* pctxt, H245NewATMVCCommand_aal* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_multiplex                                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCCommand_multiplex_noMultiplex 1
+#define T_H245NewATMVCCommand_multiplex_transportStream 2
+#define T_H245NewATMVCCommand_multiplex_programStream 3
+#define T_H245NewATMVCCommand_multiplex_extElem1 4
+
+typedef struct EXTERN H245NewATMVCCommand_multiplex {
+   int t;
+} H245NewATMVCCommand_multiplex;
+
+EXTERN int asn1PE_H245NewATMVCCommand_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_multiplex* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_multiplex* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_reverseParameters_multiplex               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCCommand_reverseParameters_multiplex_noMultiplex 1
+#define T_H245NewATMVCCommand_reverseParameters_multiplex_transportStream 2
+#define T_H245NewATMVCCommand_reverseParameters_multiplex_programStream 3
+#define T_H245NewATMVCCommand_reverseParameters_multiplex_extElem1 4
+
+typedef struct EXTERN H245NewATMVCCommand_reverseParameters_multiplex {
+   int t;
+} H245NewATMVCCommand_reverseParameters_multiplex;
+
+EXTERN int asn1PE_H245NewATMVCCommand_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters_multiplex* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters_multiplex* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_reverseParameters                         */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NewATMVCCommand_reverseParameters {
+   ASN1USINT bitRate;
+   ASN1BOOL bitRateLockedToPCRClock;
+   ASN1BOOL bitRateLockedToNetworkClock;
+   H245NewATMVCCommand_reverseParameters_multiplex multiplex;
+} H245NewATMVCCommand_reverseParameters;
+
+EXTERN int asn1PE_H245NewATMVCCommand_reverseParameters (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand_reverseParameters (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand                                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NewATMVCCommand {
+   ASN1USINT resourceID;
+   ASN1USINT bitRate;
+   ASN1BOOL bitRateLockedToPCRClock;
+   ASN1BOOL bitRateLockedToNetworkClock;
+   H245NewATMVCCommand_aal aal;
+   H245NewATMVCCommand_multiplex multiplex;
+   H245NewATMVCCommand_reverseParameters reverseParameters;
+} H245NewATMVCCommand;
+
+EXTERN int asn1PE_H245NewATMVCCommand (OOCTXT* pctxt, H245NewATMVCCommand* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCCommand (OOCTXT* pctxt, H245NewATMVCCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationCommand_status              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MobileMultilinkReconfigurationCommand_status_synchronized_ 1
+#define T_H245MobileMultilinkReconfigurationCommand_status_reconfiguration 2
+#define T_H245MobileMultilinkReconfigurationCommand_status_extElem1 3
+
+typedef struct EXTERN H245MobileMultilinkReconfigurationCommand_status {
+   int t;
+} H245MobileMultilinkReconfigurationCommand_status;
+
+EXTERN int asn1PE_H245MobileMultilinkReconfigurationCommand_status (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand_status* pvalue);
+
+EXTERN int asn1PD_H245MobileMultilinkReconfigurationCommand_status (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand_status* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationCommand                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MobileMultilinkReconfigurationCommand {
+   ASN1UINT8 sampleSize;
+   ASN1UINT8 samplesPerFrame;
+   H245MobileMultilinkReconfigurationCommand_status status;
+} H245MobileMultilinkReconfigurationCommand;
+
+EXTERN int asn1PE_H245MobileMultilinkReconfigurationCommand (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand* pvalue);
+
+EXTERN int asn1PD_H245MobileMultilinkReconfigurationCommand (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  CommandMessage                                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245CommandMessage_nonStandard 1
+#define T_H245CommandMessage_maintenanceLoopOffCommand 2
+#define T_H245CommandMessage_sendTerminalCapabilitySet 3
+#define T_H245CommandMessage_encryptionCommand 4
+#define T_H245CommandMessage_flowControlCommand 5
+#define T_H245CommandMessage_endSessionCommand 6
+#define T_H245CommandMessage_miscellaneousCommand 7
+#define T_H245CommandMessage_communicationModeCommand 8
+#define T_H245CommandMessage_conferenceCommand 9
+#define T_H245CommandMessage_h223MultiplexReconfiguration 10
+#define T_H245CommandMessage_newATMVCCommand 11
+#define T_H245CommandMessage_mobileMultilinkReconfigurationCommand 12
+#define T_H245CommandMessage_extElem1   13
+
+typedef struct EXTERN H245CommandMessage {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      H245MaintenanceLoopOffCommand *maintenanceLoopOffCommand;
+      /* t = 3 */
+      H245SendTerminalCapabilitySet *sendTerminalCapabilitySet;
+      /* t = 4 */
+      H245EncryptionCommand *encryptionCommand;
+      /* t = 5 */
+      H245FlowControlCommand *flowControlCommand;
+      /* t = 6 */
+      H245EndSessionCommand *endSessionCommand;
+      /* t = 7 */
+      H245MiscellaneousCommand *miscellaneousCommand;
+      /* t = 8 */
+      H245CommunicationModeCommand *communicationModeCommand;
+      /* t = 9 */
+      H245ConferenceCommand *conferenceCommand;
+      /* t = 10 */
+      H245H223MultiplexReconfiguration *h223MultiplexReconfiguration;
+      /* t = 11 */
+      H245NewATMVCCommand *newATMVCCommand;
+      /* t = 12 */
+      H245MobileMultilinkReconfigurationCommand *mobileMultilinkReconfigurationCommand;
+      /* t = 13 */
+   } u;
+} H245CommandMessage;
+
+EXTERN int asn1PE_H245CommandMessage (OOCTXT* pctxt, H245CommandMessage* pvalue);
+
+EXTERN int asn1PD_H245CommandMessage (OOCTXT* pctxt, H245CommandMessage* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotUnderstood                                     */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FunctionNotUnderstood_request 1
+#define T_H245FunctionNotUnderstood_response 2
+#define T_H245FunctionNotUnderstood_command 3
+
+typedef struct EXTERN H245FunctionNotUnderstood {
+   int t;
+   union {
+      /* t = 1 */
+      H245RequestMessage *request;
+      /* t = 2 */
+      H245ResponseMessage *response;
+      /* t = 3 */
+      H245CommandMessage *command;
+   } u;
+} H245FunctionNotUnderstood;
+
+EXTERN int asn1PE_H245FunctionNotUnderstood (OOCTXT* pctxt, H245FunctionNotUnderstood* pvalue);
+
+EXTERN int asn1PD_H245FunctionNotUnderstood (OOCTXT* pctxt, H245FunctionNotUnderstood* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationRelease                           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MasterSlaveDeterminationRelease {
+   ASN1OCTET __dummy__;
+} H245MasterSlaveDeterminationRelease;
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationRelease (OOCTXT* pctxt, H245MasterSlaveDeterminationRelease* pvalue);
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationRelease (OOCTXT* pctxt, H245MasterSlaveDeterminationRelease* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetRelease                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TerminalCapabilitySetRelease {
+   ASN1OCTET __dummy__;
+} H245TerminalCapabilitySetRelease;
+
+EXTERN int asn1PE_H245TerminalCapabilitySetRelease (OOCTXT* pctxt, H245TerminalCapabilitySetRelease* pvalue);
+
+EXTERN int asn1PD_H245TerminalCapabilitySetRelease (OOCTXT* pctxt, H245TerminalCapabilitySetRelease* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelConfirm                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245OpenLogicalChannelConfirm {
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+} H245OpenLogicalChannelConfirm;
+
+EXTERN int asn1PE_H245OpenLogicalChannelConfirm (OOCTXT* pctxt, H245OpenLogicalChannelConfirm* pvalue);
+
+EXTERN int asn1PD_H245OpenLogicalChannelConfirm (OOCTXT* pctxt, H245OpenLogicalChannelConfirm* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseRelease                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestChannelCloseRelease {
+   H245LogicalChannelNumber forwardLogicalChannelNumber;
+} H245RequestChannelCloseRelease;
+
+EXTERN int asn1PE_H245RequestChannelCloseRelease (OOCTXT* pctxt, H245RequestChannelCloseRelease* pvalue);
+
+EXTERN int asn1PD_H245RequestChannelCloseRelease (OOCTXT* pctxt, H245RequestChannelCloseRelease* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendRelease_multiplexTableEntryNumber       */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexEntrySendRelease_multiplexTableEntryNumber {
+   ASN1UINT n;
+   H245MultiplexTableEntryNumber elem[15];
+} H245MultiplexEntrySendRelease_multiplexTableEntryNumber;
+
+EXTERN int asn1PE_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendRelease_multiplexTableEntryNumber* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendRelease_multiplexTableEntryNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendRelease                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultiplexEntrySendRelease {
+   H245MultiplexEntrySendRelease_multiplexTableEntryNumber multiplexTableEntryNumber;
+} H245MultiplexEntrySendRelease;
+
+EXTERN int asn1PE_H245MultiplexEntrySendRelease (OOCTXT* pctxt, H245MultiplexEntrySendRelease* pvalue);
+
+EXTERN int asn1PD_H245MultiplexEntrySendRelease (OOCTXT* pctxt, H245MultiplexEntrySendRelease* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRelease_entryNumbers                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntryRelease_entryNumbers {
+   ASN1UINT n;
+   H245MultiplexTableEntryNumber elem[15];
+} H245RequestMultiplexEntryRelease_entryNumbers;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryRelease_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryRelease_entryNumbers* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryRelease_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryRelease_entryNumbers* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRelease                              */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestMultiplexEntryRelease {
+   H245RequestMultiplexEntryRelease_entryNumbers entryNumbers;
+} H245RequestMultiplexEntryRelease;
+
+EXTERN int asn1PE_H245RequestMultiplexEntryRelease (OOCTXT* pctxt, H245RequestMultiplexEntryRelease* pvalue);
+
+EXTERN int asn1PD_H245RequestMultiplexEntryRelease (OOCTXT* pctxt, H245RequestMultiplexEntryRelease* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeRelease                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245RequestModeRelease {
+   ASN1OCTET __dummy__;
+} H245RequestModeRelease;
+
+EXTERN int asn1PE_H245RequestModeRelease (OOCTXT* pctxt, H245RequestModeRelease* pvalue);
+
+EXTERN int asn1PD_H245RequestModeRelease (OOCTXT* pctxt, H245RequestModeRelease* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication_type_videoNotDecodedMBs           */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MiscellaneousIndication_type_videoNotDecodedMBs {
+   ASN1USINT firstMB;
+   ASN1USINT numberOfMBs;
+   ASN1UINT8 temporalReference;
+} H245MiscellaneousIndication_type_videoNotDecodedMBs;
+
+EXTERN int asn1PE_H245MiscellaneousIndication_type_videoNotDecodedMBs (OOCTXT* pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousIndication_type_videoNotDecodedMBs (OOCTXT* pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication_type                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MiscellaneousIndication_type_logicalChannelActive 1
+#define T_H245MiscellaneousIndication_type_logicalChannelInactive 2
+#define T_H245MiscellaneousIndication_type_multipointConference 3
+#define T_H245MiscellaneousIndication_type_cancelMultipointConference 4
+#define T_H245MiscellaneousIndication_type_multipointZeroComm 5
+#define T_H245MiscellaneousIndication_type_cancelMultipointZeroComm 6
+#define T_H245MiscellaneousIndication_type_multipointSecondaryStatus 7
+#define T_H245MiscellaneousIndication_type_cancelMultipointSecondaryStatus 8
+#define T_H245MiscellaneousIndication_type_videoIndicateReadyToActivate 9
+#define T_H245MiscellaneousIndication_type_videoTemporalSpatialTradeOff 10
+#define T_H245MiscellaneousIndication_type_videoNotDecodedMBs 11
+#define T_H245MiscellaneousIndication_type_transportCapability 12
+#define T_H245MiscellaneousIndication_type_extElem1 13
+
+typedef struct EXTERN H245MiscellaneousIndication_type {
+   int t;
+   union {
+      /* t = 1 */
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      /* t = 9 */
+      /* t = 10 */
+      ASN1UINT8 videoTemporalSpatialTradeOff;
+      /* t = 11 */
+      H245MiscellaneousIndication_type_videoNotDecodedMBs *videoNotDecodedMBs;
+      /* t = 12 */
+      H245TransportCapability *transportCapability;
+      /* t = 13 */
+   } u;
+} H245MiscellaneousIndication_type;
+
+EXTERN int asn1PE_H245MiscellaneousIndication_type (OOCTXT* pctxt, H245MiscellaneousIndication_type* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousIndication_type (OOCTXT* pctxt, H245MiscellaneousIndication_type* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication                                   */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MiscellaneousIndication {
+   H245LogicalChannelNumber logicalChannelNumber;
+   H245MiscellaneousIndication_type type;
+} H245MiscellaneousIndication;
+
+EXTERN int asn1PE_H245MiscellaneousIndication (OOCTXT* pctxt, H245MiscellaneousIndication* pvalue);
+
+EXTERN int asn1PD_H245MiscellaneousIndication (OOCTXT* pctxt, H245MiscellaneousIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  JitterIndication_scope                                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245JitterIndication_scope_logicalChannelNumber 1
+#define T_H245JitterIndication_scope_resourceID 2
+#define T_H245JitterIndication_scope_wholeMultiplex 3
+
+typedef struct EXTERN H245JitterIndication_scope {
+   int t;
+   union {
+      /* t = 1 */
+      H245LogicalChannelNumber logicalChannelNumber;
+      /* t = 2 */
+      ASN1USINT resourceID;
+      /* t = 3 */
+   } u;
+} H245JitterIndication_scope;
+
+EXTERN int asn1PE_H245JitterIndication_scope (OOCTXT* pctxt, H245JitterIndication_scope* pvalue);
+
+EXTERN int asn1PD_H245JitterIndication_scope (OOCTXT* pctxt, H245JitterIndication_scope* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  JitterIndication                                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245JitterIndication {
+   struct {
+      unsigned skippedFrameCountPresent : 1;
+      unsigned additionalDecoderBufferPresent : 1;
+   } m;
+   H245JitterIndication_scope scope;
+   ASN1UINT8 estimatedReceivedJitterMantissa;
+   ASN1UINT8 estimatedReceivedJitterExponent;
+   ASN1UINT8 skippedFrameCount;
+   ASN1UINT additionalDecoderBuffer;
+} H245JitterIndication;
+
+EXTERN int asn1PE_H245JitterIndication (OOCTXT* pctxt, H245JitterIndication* pvalue);
+
+EXTERN int asn1PD_H245JitterIndication (OOCTXT* pctxt, H245JitterIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H223SkewIndication                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H223SkewIndication {
+   H245LogicalChannelNumber logicalChannelNumber1;
+   H245LogicalChannelNumber logicalChannelNumber2;
+   ASN1USINT skew;
+} H245H223SkewIndication;
+
+EXTERN int asn1PE_H245H223SkewIndication (OOCTXT* pctxt, H245H223SkewIndication* pvalue);
+
+EXTERN int asn1PD_H245H223SkewIndication (OOCTXT* pctxt, H245H223SkewIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1_clockRecovery                 */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCIndication_aal_aal1_clockRecovery_nullClockRecovery 1
+#define T_H245NewATMVCIndication_aal_aal1_clockRecovery_srtsClockRecovery 2
+#define T_H245NewATMVCIndication_aal_aal1_clockRecovery_adaptiveClockRecovery 3
+#define T_H245NewATMVCIndication_aal_aal1_clockRecovery_extElem1 4
+
+typedef struct EXTERN H245NewATMVCIndication_aal_aal1_clockRecovery {
+   int t;
+} H245NewATMVCIndication_aal_aal1_clockRecovery;
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_clockRecovery* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_clockRecovery* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1_errorCorrection               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_nullErrorCorrection 1
+#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_longInterleaver 2
+#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_shortInterleaver 3
+#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_errorCorrectionOnly 4
+#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_extElem1 5
+
+typedef struct EXTERN H245NewATMVCIndication_aal_aal1_errorCorrection {
+   int t;
+} H245NewATMVCIndication_aal_aal1_errorCorrection;
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_errorCorrection* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_errorCorrection* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NewATMVCIndication_aal_aal1 {
+   H245NewATMVCIndication_aal_aal1_clockRecovery clockRecovery;
+   H245NewATMVCIndication_aal_aal1_errorCorrection errorCorrection;
+   ASN1BOOL structuredDataTransfer;
+   ASN1BOOL partiallyFilledCells;
+} H245NewATMVCIndication_aal_aal1;
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal5                               */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NewATMVCIndication_aal_aal5 {
+   ASN1USINT forwardMaximumSDUSize;
+   ASN1USINT backwardMaximumSDUSize;
+} H245NewATMVCIndication_aal_aal5;
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal_aal5 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal5* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal_aal5 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal5* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal                                    */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCIndication_aal_aal1 1
+#define T_H245NewATMVCIndication_aal_aal5 2
+#define T_H245NewATMVCIndication_aal_extElem1 3
+
+typedef struct EXTERN H245NewATMVCIndication_aal {
+   int t;
+   union {
+      /* t = 1 */
+      H245NewATMVCIndication_aal_aal1 *aal1;
+      /* t = 2 */
+      H245NewATMVCIndication_aal_aal5 *aal5;
+      /* t = 3 */
+   } u;
+} H245NewATMVCIndication_aal;
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal (OOCTXT* pctxt, H245NewATMVCIndication_aal* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal (OOCTXT* pctxt, H245NewATMVCIndication_aal* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_multiplex                              */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCIndication_multiplex_noMultiplex 1
+#define T_H245NewATMVCIndication_multiplex_transportStream 2
+#define T_H245NewATMVCIndication_multiplex_programStream 3
+#define T_H245NewATMVCIndication_multiplex_extElem1 4
+
+typedef struct EXTERN H245NewATMVCIndication_multiplex {
+   int t;
+} H245NewATMVCIndication_multiplex;
+
+EXTERN int asn1PE_H245NewATMVCIndication_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_multiplex* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_multiplex* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_reverseParameters_multiplex            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245NewATMVCIndication_reverseParameters_multiplex_noMultiplex 1
+#define T_H245NewATMVCIndication_reverseParameters_multiplex_transportStream 2
+#define T_H245NewATMVCIndication_reverseParameters_multiplex_programStream 3
+#define T_H245NewATMVCIndication_reverseParameters_multiplex_extElem1 4
+
+typedef struct EXTERN H245NewATMVCIndication_reverseParameters_multiplex {
+   int t;
+} H245NewATMVCIndication_reverseParameters_multiplex;
+
+EXTERN int asn1PE_H245NewATMVCIndication_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters_multiplex* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters_multiplex* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_reverseParameters                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NewATMVCIndication_reverseParameters {
+   ASN1USINT bitRate;
+   ASN1BOOL bitRateLockedToPCRClock;
+   ASN1BOOL bitRateLockedToNetworkClock;
+   H245NewATMVCIndication_reverseParameters_multiplex multiplex;
+} H245NewATMVCIndication_reverseParameters;
+
+EXTERN int asn1PE_H245NewATMVCIndication_reverseParameters (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication_reverseParameters (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication                                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245NewATMVCIndication {
+   struct {
+      unsigned reverseParametersPresent : 1;
+   } m;
+   ASN1USINT resourceID;
+   ASN1USINT bitRate;
+   ASN1BOOL bitRateLockedToPCRClock;
+   ASN1BOOL bitRateLockedToNetworkClock;
+   H245NewATMVCIndication_aal aal;
+   H245NewATMVCIndication_multiplex multiplex;
+   H245NewATMVCIndication_reverseParameters reverseParameters;
+} H245NewATMVCIndication;
+
+EXTERN int asn1PE_H245NewATMVCIndication (OOCTXT* pctxt, H245NewATMVCIndication* pvalue);
+
+EXTERN int asn1PD_H245NewATMVCIndication (OOCTXT* pctxt, H245NewATMVCIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_userInputSupportIndication            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245UserInputIndication_userInputSupportIndication_nonStandard 1
+#define T_H245UserInputIndication_userInputSupportIndication_basicString 2
+#define T_H245UserInputIndication_userInputSupportIndication_iA5String 3
+#define T_H245UserInputIndication_userInputSupportIndication_generalString 4
+#define T_H245UserInputIndication_userInputSupportIndication_extElem1 5
+
+typedef struct EXTERN H245UserInputIndication_userInputSupportIndication {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      /* t = 3 */
+      /* t = 4 */
+      /* t = 5 */
+   } u;
+} H245UserInputIndication_userInputSupportIndication;
+
+EXTERN int asn1PE_H245UserInputIndication_userInputSupportIndication (OOCTXT* pctxt, H245UserInputIndication_userInputSupportIndication* pvalue);
+
+EXTERN int asn1PD_H245UserInputIndication_userInputSupportIndication (OOCTXT* pctxt, H245UserInputIndication_userInputSupportIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signal_rtp                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UserInputIndication_signal_rtp {
+   struct {
+      unsigned timestampPresent : 1;
+      unsigned expirationTimePresent : 1;
+   } m;
+   ASN1UINT timestamp;
+   ASN1UINT expirationTime;
+   H245LogicalChannelNumber logicalChannelNumber;
+} H245UserInputIndication_signal_rtp;
+
+EXTERN int asn1PE_H245UserInputIndication_signal_rtp (OOCTXT* pctxt, H245UserInputIndication_signal_rtp* pvalue);
+
+EXTERN int asn1PD_H245UserInputIndication_signal_rtp (OOCTXT* pctxt, H245UserInputIndication_signal_rtp* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signal                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UserInputIndication_signal {
+   struct {
+      unsigned durationPresent : 1;
+      unsigned rtpPresent : 1;
+      unsigned rtpPayloadIndicationPresent : 1;
+   } m;
+   ASN1IA5String signalType;
+   ASN1USINT duration;
+   H245UserInputIndication_signal_rtp rtp;
+} H245UserInputIndication_signal;
+
+EXTERN int asn1PE_H245UserInputIndication_signal (OOCTXT* pctxt, H245UserInputIndication_signal* pvalue);
+
+EXTERN int asn1PD_H245UserInputIndication_signal (OOCTXT* pctxt, H245UserInputIndication_signal* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signalUpdate_rtp                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UserInputIndication_signalUpdate_rtp {
+   H245LogicalChannelNumber logicalChannelNumber;
+} H245UserInputIndication_signalUpdate_rtp;
+
+EXTERN int asn1PE_H245UserInputIndication_signalUpdate_rtp (OOCTXT* pctxt, H245UserInputIndication_signalUpdate_rtp* pvalue);
+
+EXTERN int asn1PD_H245UserInputIndication_signalUpdate_rtp (OOCTXT* pctxt, H245UserInputIndication_signalUpdate_rtp* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signalUpdate                          */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UserInputIndication_signalUpdate {
+   struct {
+      unsigned rtpPresent : 1;
+   } m;
+   ASN1USINT duration;
+   H245UserInputIndication_signalUpdate_rtp rtp;
+} H245UserInputIndication_signalUpdate;
+
+EXTERN int asn1PE_H245UserInputIndication_signalUpdate (OOCTXT* pctxt, H245UserInputIndication_signalUpdate* pvalue);
+
+EXTERN int asn1PD_H245UserInputIndication_signalUpdate (OOCTXT* pctxt, H245UserInputIndication_signalUpdate* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_extendedAlphanumeric                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245UserInputIndication_extendedAlphanumeric {
+   struct {
+      unsigned rtpPayloadIndicationPresent : 1;
+   } m;
+   ASN1GeneralString alphanumeric;
+} H245UserInputIndication_extendedAlphanumeric;
+
+EXTERN int asn1PE_H245UserInputIndication_extendedAlphanumeric (OOCTXT* pctxt, H245UserInputIndication_extendedAlphanumeric* pvalue);
+
+EXTERN int asn1PD_H245UserInputIndication_extendedAlphanumeric (OOCTXT* pctxt, H245UserInputIndication_extendedAlphanumeric* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245UserInputIndication_nonStandard 1
+#define T_H245UserInputIndication_alphanumeric 2
+#define T_H245UserInputIndication_userInputSupportIndication 3
+#define T_H245UserInputIndication_signal 4
+#define T_H245UserInputIndication_signalUpdate 5
+#define T_H245UserInputIndication_extendedAlphanumeric 6
+#define T_H245UserInputIndication_extElem1 7
+
+typedef struct EXTERN H245UserInputIndication {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardParameter *nonStandard;
+      /* t = 2 */
+      ASN1GeneralString alphanumeric;
+      /* t = 3 */
+      H245UserInputIndication_userInputSupportIndication *userInputSupportIndication;
+      /* t = 4 */
+      H245UserInputIndication_signal *signal;
+      /* t = 5 */
+      H245UserInputIndication_signalUpdate *signalUpdate;
+      /* t = 6 */
+      H245UserInputIndication_extendedAlphanumeric *extendedAlphanumeric;
+      /* t = 7 */
+   } u;
+} H245UserInputIndication;
+
+EXTERN int asn1PE_H245UserInputIndication (OOCTXT* pctxt, H245UserInputIndication* pvalue);
+
+EXTERN int asn1PD_H245UserInputIndication (OOCTXT* pctxt, H245UserInputIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  H2250MaximumSkewIndication                                */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245H2250MaximumSkewIndication {
+   H245LogicalChannelNumber logicalChannelNumber1;
+   H245LogicalChannelNumber logicalChannelNumber2;
+   ASN1USINT maximumSkew;
+} H245H2250MaximumSkewIndication;
+
+EXTERN int asn1PE_H245H2250MaximumSkewIndication (OOCTXT* pctxt, H245H2250MaximumSkewIndication* pvalue);
+
+EXTERN int asn1PD_H245H2250MaximumSkewIndication (OOCTXT* pctxt, H245H2250MaximumSkewIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MCLocationIndication                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MCLocationIndication {
+   H245TransportAddress signalAddress;
+} H245MCLocationIndication;
+
+EXTERN int asn1PE_H245MCLocationIndication (OOCTXT* pctxt, H245MCLocationIndication* pvalue);
+
+EXTERN int asn1PD_H245MCLocationIndication (OOCTXT* pctxt, H245MCLocationIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalYouAreSeeingInSubPictureNumber                    */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245TerminalYouAreSeeingInSubPictureNumber {
+   H245TerminalNumber terminalNumber;
+   ASN1UINT8 subPictureNumber;
+} H245TerminalYouAreSeeingInSubPictureNumber;
+
+EXTERN int asn1PE_H245TerminalYouAreSeeingInSubPictureNumber (OOCTXT* pctxt, H245TerminalYouAreSeeingInSubPictureNumber* pvalue);
+
+EXTERN int asn1PD_H245TerminalYouAreSeeingInSubPictureNumber (OOCTXT* pctxt, H245TerminalYouAreSeeingInSubPictureNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VideoIndicateCompose                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VideoIndicateCompose {
+   ASN1UINT8 compositionNumber;
+} H245VideoIndicateCompose;
+
+EXTERN int asn1PE_H245VideoIndicateCompose (OOCTXT* pctxt, H245VideoIndicateCompose* pvalue);
+
+EXTERN int asn1PD_H245VideoIndicateCompose (OOCTXT* pctxt, H245VideoIndicateCompose* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceIndication                                      */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245ConferenceIndication_sbeNumber 1
+#define T_H245ConferenceIndication_terminalNumberAssign 2
+#define T_H245ConferenceIndication_terminalJoinedConference 3
+#define T_H245ConferenceIndication_terminalLeftConference 4
+#define T_H245ConferenceIndication_seenByAtLeastOneOther 5
+#define T_H245ConferenceIndication_cancelSeenByAtLeastOneOther 6
+#define T_H245ConferenceIndication_seenByAll 7
+#define T_H245ConferenceIndication_cancelSeenByAll 8
+#define T_H245ConferenceIndication_terminalYouAreSeeing 9
+#define T_H245ConferenceIndication_requestForFloor 10
+#define T_H245ConferenceIndication_withdrawChairToken 11
+#define T_H245ConferenceIndication_floorRequested 12
+#define T_H245ConferenceIndication_terminalYouAreSeeingInSubPictureNumber 13
+#define T_H245ConferenceIndication_videoIndicateCompose 14
+#define T_H245ConferenceIndication_extElem1 15
+
+typedef struct EXTERN H245ConferenceIndication {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1UINT8 sbeNumber;
+      /* t = 2 */
+      H245TerminalLabel *terminalNumberAssign;
+      /* t = 3 */
+      H245TerminalLabel *terminalJoinedConference;
+      /* t = 4 */
+      H245TerminalLabel *terminalLeftConference;
+      /* t = 5 */
+      /* t = 6 */
+      /* t = 7 */
+      /* t = 8 */
+      /* t = 9 */
+      H245TerminalLabel *terminalYouAreSeeing;
+      /* t = 10 */
+      /* t = 11 */
+      /* t = 12 */
+      H245TerminalLabel *floorRequested;
+      /* t = 13 */
+      H245TerminalYouAreSeeingInSubPictureNumber *terminalYouAreSeeingInSubPictureNumber;
+      /* t = 14 */
+      H245VideoIndicateCompose *videoIndicateCompose;
+      /* t = 15 */
+   } u;
+} H245ConferenceIndication;
+
+EXTERN int asn1PE_H245ConferenceIndication (OOCTXT* pctxt, H245ConferenceIndication* pvalue);
+
+EXTERN int asn1PD_H245ConferenceIndication (OOCTXT* pctxt, H245ConferenceIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification_productNumber                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VendorIdentification_productNumber {
+   ASN1UINT numocts;
+   ASN1OCTET data[256];
+} H245VendorIdentification_productNumber;
+
+EXTERN int asn1PE_H245VendorIdentification_productNumber (OOCTXT* pctxt, H245VendorIdentification_productNumber* pvalue);
+
+EXTERN int asn1PD_H245VendorIdentification_productNumber (OOCTXT* pctxt, H245VendorIdentification_productNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification_versionNumber                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VendorIdentification_versionNumber {
+   ASN1UINT numocts;
+   ASN1OCTET data[256];
+} H245VendorIdentification_versionNumber;
+
+EXTERN int asn1PE_H245VendorIdentification_versionNumber (OOCTXT* pctxt, H245VendorIdentification_versionNumber* pvalue);
+
+EXTERN int asn1PD_H245VendorIdentification_versionNumber (OOCTXT* pctxt, H245VendorIdentification_versionNumber* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245VendorIdentification {
+   struct {
+      unsigned productNumberPresent : 1;
+      unsigned versionNumberPresent : 1;
+   } m;
+   H245NonStandardIdentifier vendor;
+   H245VendorIdentification_productNumber productNumber;
+   H245VendorIdentification_versionNumber versionNumber;
+} H245VendorIdentification;
+
+EXTERN int asn1PE_H245VendorIdentification (OOCTXT* pctxt, H245VendorIdentification* pvalue);
+
+EXTERN int asn1PD_H245VendorIdentification (OOCTXT* pctxt, H245VendorIdentification* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotSupported_cause                                */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FunctionNotSupported_cause_syntaxError 1
+#define T_H245FunctionNotSupported_cause_semanticError 2
+#define T_H245FunctionNotSupported_cause_unknownFunction 3
+#define T_H245FunctionNotSupported_cause_extElem1 4
+
+typedef struct EXTERN H245FunctionNotSupported_cause {
+   int t;
+} H245FunctionNotSupported_cause;
+
+EXTERN int asn1PE_H245FunctionNotSupported_cause (OOCTXT* pctxt, H245FunctionNotSupported_cause* pvalue);
+
+EXTERN int asn1PD_H245FunctionNotSupported_cause (OOCTXT* pctxt, H245FunctionNotSupported_cause* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotSupported                                      */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FunctionNotSupported {
+   struct {
+      unsigned returnedFunctionPresent : 1;
+   } m;
+   H245FunctionNotSupported_cause cause;
+   ASN1DynOctStr returnedFunction;
+} H245FunctionNotSupported;
+
+EXTERN int asn1PE_H245FunctionNotSupported (OOCTXT* pctxt, H245FunctionNotSupported* pvalue);
+
+EXTERN int asn1PD_H245FunctionNotSupported (OOCTXT* pctxt, H245FunctionNotSupported* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication_crcDesired                            */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkIndication_crcDesired {
+   ASN1OCTET __dummy__;
+} H245MultilinkIndication_crcDesired;
+
+EXTERN int asn1PE_H245MultilinkIndication_crcDesired (OOCTXT* pctxt, H245MultilinkIndication_crcDesired* pvalue);
+
+EXTERN int asn1PD_H245MultilinkIndication_crcDesired (OOCTXT* pctxt, H245MultilinkIndication_crcDesired* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication_excessiveError                        */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MultilinkIndication_excessiveError {
+   H245ConnectionIdentifier connectionIdentifier;
+} H245MultilinkIndication_excessiveError;
+
+EXTERN int asn1PE_H245MultilinkIndication_excessiveError (OOCTXT* pctxt, H245MultilinkIndication_excessiveError* pvalue);
+
+EXTERN int asn1PD_H245MultilinkIndication_excessiveError (OOCTXT* pctxt, H245MultilinkIndication_excessiveError* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication                                       */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultilinkIndication_nonStandard 1
+#define T_H245MultilinkIndication_crcDesired 2
+#define T_H245MultilinkIndication_excessiveError 3
+#define T_H245MultilinkIndication_extElem1 4
+
+typedef struct EXTERN H245MultilinkIndication {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      H245MultilinkIndication_crcDesired *crcDesired;
+      /* t = 3 */
+      H245MultilinkIndication_excessiveError *excessiveError;
+      /* t = 4 */
+   } u;
+} H245MultilinkIndication;
+
+EXTERN int asn1PE_H245MultilinkIndication (OOCTXT* pctxt, H245MultilinkIndication* pvalue);
+
+EXTERN int asn1PD_H245MultilinkIndication (OOCTXT* pctxt, H245MultilinkIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRelease                                 */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245LogicalChannelRateRelease {
+   ASN1OCTET __dummy__;
+} H245LogicalChannelRateRelease;
+
+EXTERN int asn1PE_H245LogicalChannelRateRelease (OOCTXT* pctxt, H245LogicalChannelRateRelease* pvalue);
+
+EXTERN int asn1PD_H245LogicalChannelRateRelease (OOCTXT* pctxt, H245LogicalChannelRateRelease* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication_scope                               */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FlowControlIndication_scope_logicalChannelNumber 1
+#define T_H245FlowControlIndication_scope_resourceID 2
+#define T_H245FlowControlIndication_scope_wholeMultiplex 3
+
+typedef struct EXTERN H245FlowControlIndication_scope {
+   int t;
+   union {
+      /* t = 1 */
+      H245LogicalChannelNumber logicalChannelNumber;
+      /* t = 2 */
+      ASN1USINT resourceID;
+      /* t = 3 */
+   } u;
+} H245FlowControlIndication_scope;
+
+EXTERN int asn1PE_H245FlowControlIndication_scope (OOCTXT* pctxt, H245FlowControlIndication_scope* pvalue);
+
+EXTERN int asn1PD_H245FlowControlIndication_scope (OOCTXT* pctxt, H245FlowControlIndication_scope* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication_restriction                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245FlowControlIndication_restriction_maximumBitRate 1
+#define T_H245FlowControlIndication_restriction_noRestriction 2
+
+typedef struct EXTERN H245FlowControlIndication_restriction {
+   int t;
+   union {
+      /* t = 1 */
+      ASN1UINT maximumBitRate;
+      /* t = 2 */
+   } u;
+} H245FlowControlIndication_restriction;
+
+EXTERN int asn1PE_H245FlowControlIndication_restriction (OOCTXT* pctxt, H245FlowControlIndication_restriction* pvalue);
+
+EXTERN int asn1PD_H245FlowControlIndication_restriction (OOCTXT* pctxt, H245FlowControlIndication_restriction* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication                                     */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245FlowControlIndication {
+   H245FlowControlIndication_scope scope;
+   H245FlowControlIndication_restriction restriction;
+} H245FlowControlIndication;
+
+EXTERN int asn1PE_H245FlowControlIndication (OOCTXT* pctxt, H245FlowControlIndication* pvalue);
+
+EXTERN int asn1PD_H245FlowControlIndication (OOCTXT* pctxt, H245FlowControlIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationIndication                  */
+/*                                                            */
+/**************************************************************/
+
+typedef struct EXTERN H245MobileMultilinkReconfigurationIndication {
+   ASN1UINT8 sampleSize;
+   ASN1UINT8 samplesPerFrame;
+} H245MobileMultilinkReconfigurationIndication;
+
+EXTERN int asn1PE_H245MobileMultilinkReconfigurationIndication (OOCTXT* pctxt, H245MobileMultilinkReconfigurationIndication* pvalue);
+
+EXTERN int asn1PD_H245MobileMultilinkReconfigurationIndication (OOCTXT* pctxt, H245MobileMultilinkReconfigurationIndication* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  IndicationMessage                                         */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245IndicationMessage_nonStandard 1
+#define T_H245IndicationMessage_functionNotUnderstood 2
+#define T_H245IndicationMessage_masterSlaveDeterminationRelease 3
+#define T_H245IndicationMessage_terminalCapabilitySetRelease 4
+#define T_H245IndicationMessage_openLogicalChannelConfirm 5
+#define T_H245IndicationMessage_requestChannelCloseRelease 6
+#define T_H245IndicationMessage_multiplexEntrySendRelease 7
+#define T_H245IndicationMessage_requestMultiplexEntryRelease 8
+#define T_H245IndicationMessage_requestModeRelease 9
+#define T_H245IndicationMessage_miscellaneousIndication 10
+#define T_H245IndicationMessage_jitterIndication 11
+#define T_H245IndicationMessage_h223SkewIndication 12
+#define T_H245IndicationMessage_newATMVCIndication 13
+#define T_H245IndicationMessage_userInput 14
+#define T_H245IndicationMessage_h2250MaximumSkewIndication 15
+#define T_H245IndicationMessage_mcLocationIndication 16
+#define T_H245IndicationMessage_conferenceIndication 17
+#define T_H245IndicationMessage_vendorIdentification 18
+#define T_H245IndicationMessage_functionNotSupported 19
+#define T_H245IndicationMessage_multilinkIndication 20
+#define T_H245IndicationMessage_logicalChannelRateRelease 21
+#define T_H245IndicationMessage_flowControlIndication 22
+#define T_H245IndicationMessage_mobileMultilinkReconfigurationIndication 23
+#define T_H245IndicationMessage_extElem1 24
+
+typedef struct EXTERN H245IndicationMessage {
+   int t;
+   union {
+      /* t = 1 */
+      H245NonStandardMessage *nonStandard;
+      /* t = 2 */
+      H245FunctionNotUnderstood *functionNotUnderstood;
+      /* t = 3 */
+      H245MasterSlaveDeterminationRelease *masterSlaveDeterminationRelease;
+      /* t = 4 */
+      H245TerminalCapabilitySetRelease *terminalCapabilitySetRelease;
+      /* t = 5 */
+      H245OpenLogicalChannelConfirm *openLogicalChannelConfirm;
+      /* t = 6 */
+      H245RequestChannelCloseRelease *requestChannelCloseRelease;
+      /* t = 7 */
+      H245MultiplexEntrySendRelease *multiplexEntrySendRelease;
+      /* t = 8 */
+      H245RequestMultiplexEntryRelease *requestMultiplexEntryRelease;
+      /* t = 9 */
+      H245RequestModeRelease *requestModeRelease;
+      /* t = 10 */
+      H245MiscellaneousIndication *miscellaneousIndication;
+      /* t = 11 */
+      H245JitterIndication *jitterIndication;
+      /* t = 12 */
+      H245H223SkewIndication *h223SkewIndication;
+      /* t = 13 */
+      H245NewATMVCIndication *newATMVCIndication;
+      /* t = 14 */
+      H245UserInputIndication *userInput;
+      /* t = 15 */
+      H245H2250MaximumSkewIndication *h2250MaximumSkewIndication;
+      /* t = 16 */
+      H245MCLocationIndication *mcLocationIndication;
+      /* t = 17 */
+      H245ConferenceIndication *conferenceIndication;
+      /* t = 18 */
+      H245VendorIdentification *vendorIdentification;
+      /* t = 19 */
+      H245FunctionNotSupported *functionNotSupported;
+      /* t = 20 */
+      H245MultilinkIndication *multilinkIndication;
+      /* t = 21 */
+      H245LogicalChannelRateRelease *logicalChannelRateRelease;
+      /* t = 22 */
+      H245FlowControlIndication *flowControlIndication;
+      /* t = 23 */
+      H245MobileMultilinkReconfigurationIndication *mobileMultilinkReconfigurationIndication;
+      /* t = 24 */
+   } u;
+} H245IndicationMessage;
+
+EXTERN int asn1PE_H245IndicationMessage (OOCTXT* pctxt, H245IndicationMessage* pvalue);
+
+EXTERN int asn1PD_H245IndicationMessage (OOCTXT* pctxt, H245IndicationMessage* pvalue);
+
+/**************************************************************/
+/*                                                            */
+/*  MultimediaSystemControlMessage                            */
+/*                                                            */
+/**************************************************************/
+
+/* Choice tag constants */
+
+#define T_H245MultimediaSystemControlMessage_request 1
+#define T_H245MultimediaSystemControlMessage_response 2
+#define T_H245MultimediaSystemControlMessage_command 3
+#define T_H245MultimediaSystemControlMessage_indication 4
+#define T_H245MultimediaSystemControlMessage_extElem1 5
+
+typedef struct EXTERN H245MultimediaSystemControlMessage {
+   int t;
+   union {
+      /* t = 1 */
+      H245RequestMessage *request;
+      /* t = 2 */
+      H245ResponseMessage *response;
+      /* t = 3 */
+      H245CommandMessage *command;
+      /* t = 4 */
+      H245IndicationMessage *indication;
+      /* t = 5 */
+   } u;
+} H245MultimediaSystemControlMessage;
+
+EXTERN int asn1PE_H245MultimediaSystemControlMessage (OOCTXT* pctxt, H245MultimediaSystemControlMessage* pvalue);
+
+EXTERN int asn1PD_H245MultimediaSystemControlMessage (OOCTXT* pctxt, H245MultimediaSystemControlMessage* pvalue);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c
new file mode 100644
index 000000000..0ec58a82e
--- /dev/null
+++ b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c
@@ -0,0 +1,42170 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#include "ooasn1.h"
+#include "MULTIMEDIA-SYSTEM-CONTROL.h"
+#include "eventHandler.h"
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier_h221NonStandard                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode t35CountryCode */
+
+   invokeStartElement (pctxt, "t35CountryCode", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->t35CountryCode, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->t35CountryCode);
+
+   invokeEndElement (pctxt, "t35CountryCode", -1);
+
+   /* decode t35Extension */
+
+   invokeStartElement (pctxt, "t35Extension", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->t35Extension, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->t35Extension);
+
+   invokeEndElement (pctxt, "t35Extension", -1);
+
+   /* decode manufacturerCode */
+
+   invokeStartElement (pctxt, "manufacturerCode", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->manufacturerCode, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->manufacturerCode);
+
+   invokeEndElement (pctxt, "manufacturerCode", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* object */
+      case 0:
+         invokeStartElement (pctxt, "object", -1);
+
+         pvalue->u.object = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+         stat = decodeObjectIdentifier (pctxt, pvalue->u.object);
+         if (stat != ASN_OK) return stat;
+         invokeOidValue (pctxt, pvalue->u.object->numids, pvalue->u.object->subid);
+
+         invokeEndElement (pctxt, "object", -1);
+
+         break;
+
+      /* h221NonStandard */
+      case 1:
+         invokeStartElement (pctxt, "h221NonStandard", -1);
+
+         pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardIdentifier_h221NonStandard);
+
+         stat = asn1PD_H245NonStandardIdentifier_h221NonStandard (pctxt, pvalue->u.h221NonStandard);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "h221NonStandard", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode nonStandardIdentifier */
+
+   invokeStartElement (pctxt, "nonStandardIdentifier", -1);
+
+   stat = asn1PD_H245NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nonStandardIdentifier", -1);
+
+   /* decode data */
+
+   invokeStartElement (pctxt, "data", -1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->data);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->data.numocts, pvalue->data.data);
+
+   invokeEndElement (pctxt, "data", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V42bis                                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode numberOfCodewords */
+
+   invokeStartElement (pctxt, "numberOfCodewords", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->numberOfCodewords, 1U, 65536U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfCodewords);
+
+   invokeEndElement (pctxt, "numberOfCodewords", -1);
+
+   /* decode maximumStringLength */
+
+   invokeStartElement (pctxt, "maximumStringLength", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumStringLength, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumStringLength);
+
+   invokeEndElement (pctxt, "maximumStringLength", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CompressionType                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* v42bis */
+         case 0:
+            invokeStartElement (pctxt, "v42bis", -1);
+
+            pvalue->u.v42bis = ALLOC_ASN1ELEM (pctxt, H245V42bis);
+
+            stat = asn1PD_H245V42bis (pctxt, pvalue->u.v42bis);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "v42bis", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataProtocolCapability_v76wCompression                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* transmitCompression */
+         case 0:
+            invokeStartElement (pctxt, "transmitCompression", -1);
+
+            pvalue->u.transmitCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType);
+
+            stat = asn1PD_H245CompressionType (pctxt, pvalue->u.transmitCompression);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transmitCompression", -1);
+
+            break;
+
+         /* receiveCompression */
+         case 1:
+            invokeStartElement (pctxt, "receiveCompression", -1);
+
+            pvalue->u.receiveCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType);
+
+            stat = asn1PD_H245CompressionType (pctxt, pvalue->u.receiveCompression);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveCompression", -1);
+
+            break;
+
+         /* transmitAndReceiveCompression */
+         case 2:
+            invokeStartElement (pctxt, "transmitAndReceiveCompression", -1);
+
+            pvalue->u.transmitAndReceiveCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType);
+
+            stat = asn1PD_H245CompressionType (pctxt, pvalue->u.transmitAndReceiveCompression);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transmitAndReceiveCompression", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataProtocolCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* v14buffered */
+         case 1:
+            invokeStartElement (pctxt, "v14buffered", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "v14buffered", -1);
+
+            break;
+
+         /* v42lapm */
+         case 2:
+            invokeStartElement (pctxt, "v42lapm", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "v42lapm", -1);
+
+            break;
+
+         /* hdlcFrameTunnelling */
+         case 3:
+            invokeStartElement (pctxt, "hdlcFrameTunnelling", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hdlcFrameTunnelling", -1);
+
+            break;
+
+         /* h310SeparateVCStack */
+         case 4:
+            invokeStartElement (pctxt, "h310SeparateVCStack", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "h310SeparateVCStack", -1);
+
+            break;
+
+         /* h310SingleVCStack */
+         case 5:
+            invokeStartElement (pctxt, "h310SingleVCStack", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "h310SingleVCStack", -1);
+
+            break;
+
+         /* transparent */
+         case 6:
+            invokeStartElement (pctxt, "transparent", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transparent", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 8;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* segmentationAndReassembly */
+         case 8:
+            invokeStartElement (pctxt, "segmentationAndReassembly", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "segmentationAndReassembly", -1);
+
+            break;
+
+         /* hdlcFrameTunnelingwSAR */
+         case 9:
+            invokeStartElement (pctxt, "hdlcFrameTunnelingwSAR", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hdlcFrameTunnelingwSAR", -1);
+
+            break;
+
+         /* v120 */
+         case 10:
+            invokeStartElement (pctxt, "v120", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "v120", -1);
+
+            break;
+
+         /* separateLANStack */
+         case 11:
+            invokeStartElement (pctxt, "separateLANStack", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "separateLANStack", -1);
+
+            break;
+
+         /* v76wCompression */
+         case 12:
+            invokeStartElement (pctxt, "v76wCompression", -1);
+
+            pvalue->u.v76wCompression = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability_v76wCompression);
+
+            stat = asn1PD_H245DataProtocolCapability_v76wCompression (pctxt, pvalue->u.v76wCompression);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "v76wCompression", -1);
+
+            break;
+
+         /* tcp */
+         case 13:
+            invokeStartElement (pctxt, "tcp", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "tcp", -1);
+
+            break;
+
+         /* udp */
+         case 14:
+            invokeStartElement (pctxt, "udp", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "udp", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxRateManagement                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* localTCF */
+         case 0:
+            invokeStartElement (pctxt, "localTCF", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "localTCF", -1);
+
+            break;
+
+         /* transferredTCF */
+         case 1:
+            invokeStartElement (pctxt, "transferredTCF", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transferredTCF", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxUdpOptions_t38FaxUdpEC                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* t38UDPFEC */
+         case 0:
+            invokeStartElement (pctxt, "t38UDPFEC", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "t38UDPFEC", -1);
+
+            break;
+
+         /* t38UDPRedundancy */
+         case 1:
+            invokeStartElement (pctxt, "t38UDPRedundancy", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "t38UDPRedundancy", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxUdpOptions                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL optbit;
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.t38FaxMaxBufferPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.t38FaxMaxDatagramPresent = optbit;
+
+   /* decode t38FaxMaxBuffer */
+
+   if (pvalue->m.t38FaxMaxBufferPresent) {
+      invokeStartElement (pctxt, "t38FaxMaxBuffer", -1);
+
+      stat = decodeUnconsInteger (pctxt, &pvalue->t38FaxMaxBuffer);
+      if (stat != ASN_OK) return stat;
+      invokeIntValue (pctxt, pvalue->t38FaxMaxBuffer);
+
+      invokeEndElement (pctxt, "t38FaxMaxBuffer", -1);
+   }
+
+   /* decode t38FaxMaxDatagram */
+
+   if (pvalue->m.t38FaxMaxDatagramPresent) {
+      invokeStartElement (pctxt, "t38FaxMaxDatagram", -1);
+
+      stat = decodeUnconsInteger (pctxt, &pvalue->t38FaxMaxDatagram);
+      if (stat != ASN_OK) return stat;
+      invokeIntValue (pctxt, pvalue->t38FaxMaxDatagram);
+
+      invokeEndElement (pctxt, "t38FaxMaxDatagram", -1);
+   }
+
+   /* decode t38FaxUdpEC */
+
+   invokeStartElement (pctxt, "t38FaxUdpEC", -1);
+
+   stat = asn1PD_H245T38FaxUdpOptions_t38FaxUdpEC (pctxt, &pvalue->t38FaxUdpEC);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t38FaxUdpEC", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxTcpOptions                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode t38TCPBidirectionalMode */
+
+   invokeStartElement (pctxt, "t38TCPBidirectionalMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->t38TCPBidirectionalMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->t38TCPBidirectionalMode);
+
+   invokeEndElement (pctxt, "t38TCPBidirectionalMode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxProfile                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode fillBitRemoval */
+
+   invokeStartElement (pctxt, "fillBitRemoval", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fillBitRemoval);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fillBitRemoval);
+
+   invokeEndElement (pctxt, "fillBitRemoval", -1);
+
+   /* decode transcodingJBIG */
+
+   invokeStartElement (pctxt, "transcodingJBIG", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->transcodingJBIG);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->transcodingJBIG);
+
+   invokeEndElement (pctxt, "transcodingJBIG", -1);
+
+   /* decode transcodingMMR */
+
+   invokeStartElement (pctxt, "transcodingMMR", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->transcodingMMR);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->transcodingMMR);
+
+   invokeEndElement (pctxt, "transcodingMMR", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 4 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.versionPresent = 1;
+
+                     invokeStartElement (pctxt, "version", -1);
+
+                     stat = decodeConsUInt8 (pctxt, &pvalue->version, 0U, 255U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->version);
+
+                     invokeEndElement (pctxt, "version", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.t38FaxRateManagementPresent = 1;
+
+                     invokeStartElement (pctxt, "t38FaxRateManagement", -1);
+
+                     stat = asn1PD_H245T38FaxRateManagement (pctxt, &pvalue->t38FaxRateManagement);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "t38FaxRateManagement", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.t38FaxUdpOptionsPresent = 1;
+
+                     invokeStartElement (pctxt, "t38FaxUdpOptions", -1);
+
+                     stat = asn1PD_H245T38FaxUdpOptions (pctxt, &pvalue->t38FaxUdpOptions);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "t38FaxUdpOptions", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.t38FaxTcpOptionsPresent = 1;
+
+                     invokeStartElement (pctxt, "t38FaxTcpOptions", -1);
+
+                     stat = asn1PD_H245T38FaxTcpOptions (pctxt, &pvalue->t38FaxTcpOptions);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "t38FaxTcpOptions", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardMessage                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode nonStandardData */
+
+   invokeStartElement (pctxt, "nonStandardData", -1);
+
+   stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandardData);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nonStandardData", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDetermination                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalType */
+
+   invokeStartElement (pctxt, "terminalType", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->terminalType, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->terminalType);
+
+   invokeEndElement (pctxt, "terminalType", -1);
+
+   /* decode statusDeterminationNumber */
+
+   invokeStartElement (pctxt, "statusDeterminationNumber", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->statusDeterminationNumber, 0U, 16777215U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->statusDeterminationNumber);
+
+   invokeEndElement (pctxt, "statusDeterminationNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SequenceNumber                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt8 (pctxt, pvalue, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode nullClockRecovery */
+
+   invokeStartElement (pctxt, "nullClockRecovery", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->nullClockRecovery);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->nullClockRecovery);
+
+   invokeEndElement (pctxt, "nullClockRecovery", -1);
+
+   /* decode srtsClockRecovery */
+
+   invokeStartElement (pctxt, "srtsClockRecovery", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->srtsClockRecovery);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->srtsClockRecovery);
+
+   invokeEndElement (pctxt, "srtsClockRecovery", -1);
+
+   /* decode adaptiveClockRecovery */
+
+   invokeStartElement (pctxt, "adaptiveClockRecovery", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->adaptiveClockRecovery);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->adaptiveClockRecovery);
+
+   invokeEndElement (pctxt, "adaptiveClockRecovery", -1);
+
+   /* decode nullErrorCorrection */
+
+   invokeStartElement (pctxt, "nullErrorCorrection", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->nullErrorCorrection);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->nullErrorCorrection);
+
+   invokeEndElement (pctxt, "nullErrorCorrection", -1);
+
+   /* decode longInterleaver */
+
+   invokeStartElement (pctxt, "longInterleaver", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->longInterleaver);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->longInterleaver);
+
+   invokeEndElement (pctxt, "longInterleaver", -1);
+
+   /* decode shortInterleaver */
+
+   invokeStartElement (pctxt, "shortInterleaver", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->shortInterleaver);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->shortInterleaver);
+
+   invokeEndElement (pctxt, "shortInterleaver", -1);
+
+   /* decode errorCorrectionOnly */
+
+   invokeStartElement (pctxt, "errorCorrectionOnly", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->errorCorrectionOnly);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->errorCorrectionOnly);
+
+   invokeEndElement (pctxt, "errorCorrectionOnly", -1);
+
+   /* decode structuredDataTransfer */
+
+   invokeStartElement (pctxt, "structuredDataTransfer", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->structuredDataTransfer);
+
+   invokeEndElement (pctxt, "structuredDataTransfer", -1);
+
+   /* decode partiallyFilledCells */
+
+   invokeStartElement (pctxt, "partiallyFilledCells", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->partiallyFilledCells);
+
+   invokeEndElement (pctxt, "partiallyFilledCells", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal5                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardMaximumSDUSize */
+
+   invokeStartElement (pctxt, "forwardMaximumSDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->forwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->forwardMaximumSDUSize);
+
+   invokeEndElement (pctxt, "forwardMaximumSDUSize", -1);
+
+   /* decode backwardMaximumSDUSize */
+
+   invokeStartElement (pctxt, "backwardMaximumSDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->backwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->backwardMaximumSDUSize);
+
+   invokeEndElement (pctxt, "backwardMaximumSDUSize", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates_type_rangeOfBitRates       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode lowerBitRate */
+
+   invokeStartElement (pctxt, "lowerBitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->lowerBitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->lowerBitRate);
+
+   invokeEndElement (pctxt, "lowerBitRate", -1);
+
+   /* decode higherBitRate */
+
+   invokeStartElement (pctxt, "higherBitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->higherBitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->higherBitRate);
+
+   invokeEndElement (pctxt, "higherBitRate", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates_type                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* singleBitRate */
+      case 0:
+         invokeStartElement (pctxt, "singleBitRate", -1);
+
+         stat = decodeConsUInt16 (pctxt, &pvalue->u.singleBitRate, 1U, 65535U);
+         if (stat != ASN_OK) return stat;
+         invokeUIntValue (pctxt, pvalue->u.singleBitRate);
+
+         invokeEndElement (pctxt, "singleBitRate", -1);
+
+         break;
+
+      /* rangeOfBitRates */
+      case 1:
+         invokeStartElement (pctxt, "rangeOfBitRates", -1);
+
+         pvalue->u.rangeOfBitRates = ALLOC_ASN1ELEM (pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates);
+
+         stat = asn1PD_H245VCCapability_availableBitRates_type_rangeOfBitRates (pctxt, pvalue->u.rangeOfBitRates);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "rangeOfBitRates", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245VCCapability_availableBitRates_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_address_nsapAddress                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_address                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue)
+{
+   static Asn1SizeCnst internationalNumber_lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* internationalNumber */
+         case 0:
+            invokeStartElement (pctxt, "internationalNumber", -1);
+
+            addSizeConstraint (pctxt, &internationalNumber_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.internationalNumber, NUM_CANSET, 4, 4, 4);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.internationalNumber);
+
+            invokeEndElement (pctxt, "internationalNumber", -1);
+
+            break;
+
+         /* nsapAddress */
+         case 1:
+            invokeStartElement (pctxt, "nsapAddress", -1);
+
+            pvalue->u.nsapAddress = ALLOC_ASN1ELEM (pctxt, H245Q2931Address_address_nsapAddress);
+
+            stat = asn1PD_H245Q2931Address_address_nsapAddress (pctxt, pvalue->u.nsapAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nsapAddress", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_subaddress                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.subaddressPresent = optbit;
+
+   /* decode address */
+
+   invokeStartElement (pctxt, "address", -1);
+
+   stat = asn1PD_H245Q2931Address_address (pctxt, &pvalue->address);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "address", -1);
+
+   /* decode subaddress */
+
+   if (pvalue->m.subaddressPresent) {
+      invokeStartElement (pctxt, "subaddress", -1);
+
+      stat = asn1PD_H245Q2931Address_subaddress (pctxt, &pvalue->subaddress);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "subaddress", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1ViaGateway_gatewayAddress                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245Q2931Address* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245Q2931Address);
+
+      stat = asn1PD_H245Q2931Address (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1ViaGateway                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode gatewayAddress */
+
+   invokeStartElement (pctxt, "gatewayAddress", -1);
+
+   stat = asn1PD_H245VCCapability_aal1ViaGateway_gatewayAddress (pctxt, &pvalue->gatewayAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "gatewayAddress", -1);
+
+   /* decode nullClockRecovery */
+
+   invokeStartElement (pctxt, "nullClockRecovery", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->nullClockRecovery);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->nullClockRecovery);
+
+   invokeEndElement (pctxt, "nullClockRecovery", -1);
+
+   /* decode srtsClockRecovery */
+
+   invokeStartElement (pctxt, "srtsClockRecovery", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->srtsClockRecovery);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->srtsClockRecovery);
+
+   invokeEndElement (pctxt, "srtsClockRecovery", -1);
+
+   /* decode adaptiveClockRecovery */
+
+   invokeStartElement (pctxt, "adaptiveClockRecovery", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->adaptiveClockRecovery);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->adaptiveClockRecovery);
+
+   invokeEndElement (pctxt, "adaptiveClockRecovery", -1);
+
+   /* decode nullErrorCorrection */
+
+   invokeStartElement (pctxt, "nullErrorCorrection", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->nullErrorCorrection);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->nullErrorCorrection);
+
+   invokeEndElement (pctxt, "nullErrorCorrection", -1);
+
+   /* decode longInterleaver */
+
+   invokeStartElement (pctxt, "longInterleaver", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->longInterleaver);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->longInterleaver);
+
+   invokeEndElement (pctxt, "longInterleaver", -1);
+
+   /* decode shortInterleaver */
+
+   invokeStartElement (pctxt, "shortInterleaver", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->shortInterleaver);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->shortInterleaver);
+
+   invokeEndElement (pctxt, "shortInterleaver", -1);
+
+   /* decode errorCorrectionOnly */
+
+   invokeStartElement (pctxt, "errorCorrectionOnly", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->errorCorrectionOnly);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->errorCorrectionOnly);
+
+   invokeEndElement (pctxt, "errorCorrectionOnly", -1);
+
+   /* decode structuredDataTransfer */
+
+   invokeStartElement (pctxt, "structuredDataTransfer", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->structuredDataTransfer);
+
+   invokeEndElement (pctxt, "structuredDataTransfer", -1);
+
+   /* decode partiallyFilledCells */
+
+   invokeStartElement (pctxt, "partiallyFilledCells", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->partiallyFilledCells);
+
+   invokeEndElement (pctxt, "partiallyFilledCells", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.aal1Present = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.aal5Present = optbit;
+
+   /* decode aal1 */
+
+   if (pvalue->m.aal1Present) {
+      invokeStartElement (pctxt, "aal1", -1);
+
+      stat = asn1PD_H245VCCapability_aal1 (pctxt, &pvalue->aal1);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "aal1", -1);
+   }
+
+   /* decode aal5 */
+
+   if (pvalue->m.aal5Present) {
+      invokeStartElement (pctxt, "aal5", -1);
+
+      stat = asn1PD_H245VCCapability_aal5 (pctxt, &pvalue->aal5);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "aal5", -1);
+   }
+
+   /* decode transportStream */
+
+   invokeStartElement (pctxt, "transportStream", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->transportStream);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->transportStream);
+
+   invokeEndElement (pctxt, "transportStream", -1);
+
+   /* decode programStream */
+
+   invokeStartElement (pctxt, "programStream", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->programStream);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->programStream);
+
+   invokeEndElement (pctxt, "programStream", -1);
+
+   /* decode availableBitRates */
+
+   invokeStartElement (pctxt, "availableBitRates", -1);
+
+   stat = asn1PD_H245VCCapability_availableBitRates (pctxt, &pvalue->availableBitRates);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "availableBitRates", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.aal1ViaGatewayPresent = 1;
+
+                     invokeStartElement (pctxt, "aal1ViaGateway", -1);
+
+                     stat = asn1PD_H245VCCapability_aal1ViaGateway (pctxt, &pvalue->aal1ViaGateway);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "aal1ViaGateway", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SetOfH245VCCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue)
+{
+   int stat = ASN_OK;
+   H245VCCapability* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245VCCapability);
+
+         stat = asn1PD_H245VCCapability (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H222Capability                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode numberOfVCs */
+
+   invokeStartElement (pctxt, "numberOfVCs", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->numberOfVCs, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfVCs);
+
+   invokeEndElement (pctxt, "numberOfVCs", -1);
+
+   /* decode vcCapability */
+
+   invokeStartElement (pctxt, "vcCapability", -1);
+
+   stat = asn1PD_H245_SetOfH245VCCapability (pctxt, &pvalue->vcCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "vcCapability", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_h223MultiplexTableCapability_enhanced      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode maximumNestingDepth */
+
+   invokeStartElement (pctxt, "maximumNestingDepth", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->maximumNestingDepth, 1U, 15U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumNestingDepth);
+
+   invokeEndElement (pctxt, "maximumNestingDepth", -1);
+
+   /* decode maximumElementListSize */
+
+   invokeStartElement (pctxt, "maximumElementListSize", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->maximumElementListSize, 2U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumElementListSize);
+
+   invokeEndElement (pctxt, "maximumElementListSize", -1);
+
+   /* decode maximumSubElementListSize */
+
+   invokeStartElement (pctxt, "maximumSubElementListSize", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->maximumSubElementListSize, 2U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumSubElementListSize);
+
+   invokeEndElement (pctxt, "maximumSubElementListSize", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_h223MultiplexTableCapability               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* basic */
+      case 0:
+         invokeStartElement (pctxt, "basic", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "basic", -1);
+
+         break;
+
+      /* enhanced */
+      case 1:
+         invokeStartElement (pctxt, "enhanced", -1);
+
+         pvalue->u.enhanced = ALLOC_ASN1ELEM (pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced);
+
+         stat = asn1PD_H245H223Capability_h223MultiplexTableCapability_enhanced (pctxt, pvalue->u.enhanced);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "enhanced", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_mobileOperationTransmitCapability          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode modeChangeCapability */
+
+   invokeStartElement (pctxt, "modeChangeCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->modeChangeCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->modeChangeCapability);
+
+   invokeEndElement (pctxt, "modeChangeCapability", -1);
+
+   /* decode h223AnnexA */
+
+   invokeStartElement (pctxt, "h223AnnexA", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->h223AnnexA);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->h223AnnexA);
+
+   invokeEndElement (pctxt, "h223AnnexA", -1);
+
+   /* decode h223AnnexADoubleFlag */
+
+   invokeStartElement (pctxt, "h223AnnexADoubleFlag", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->h223AnnexADoubleFlag);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->h223AnnexADoubleFlag);
+
+   invokeEndElement (pctxt, "h223AnnexADoubleFlag", -1);
+
+   /* decode h223AnnexB */
+
+   invokeStartElement (pctxt, "h223AnnexB", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->h223AnnexB);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->h223AnnexB);
+
+   invokeEndElement (pctxt, "h223AnnexB", -1);
+
+   /* decode h223AnnexBwithHeader */
+
+   invokeStartElement (pctxt, "h223AnnexBwithHeader", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->h223AnnexBwithHeader);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->h223AnnexBwithHeader);
+
+   invokeEndElement (pctxt, "h223AnnexBwithHeader", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AnnexCCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode videoWithAL1M */
+
+   invokeStartElement (pctxt, "videoWithAL1M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->videoWithAL1M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->videoWithAL1M);
+
+   invokeEndElement (pctxt, "videoWithAL1M", -1);
+
+   /* decode videoWithAL2M */
+
+   invokeStartElement (pctxt, "videoWithAL2M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->videoWithAL2M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->videoWithAL2M);
+
+   invokeEndElement (pctxt, "videoWithAL2M", -1);
+
+   /* decode videoWithAL3M */
+
+   invokeStartElement (pctxt, "videoWithAL3M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->videoWithAL3M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->videoWithAL3M);
+
+   invokeEndElement (pctxt, "videoWithAL3M", -1);
+
+   /* decode audioWithAL1M */
+
+   invokeStartElement (pctxt, "audioWithAL1M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioWithAL1M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioWithAL1M);
+
+   invokeEndElement (pctxt, "audioWithAL1M", -1);
+
+   /* decode audioWithAL2M */
+
+   invokeStartElement (pctxt, "audioWithAL2M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioWithAL2M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioWithAL2M);
+
+   invokeEndElement (pctxt, "audioWithAL2M", -1);
+
+   /* decode audioWithAL3M */
+
+   invokeStartElement (pctxt, "audioWithAL3M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioWithAL3M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioWithAL3M);
+
+   invokeEndElement (pctxt, "audioWithAL3M", -1);
+
+   /* decode dataWithAL1M */
+
+   invokeStartElement (pctxt, "dataWithAL1M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dataWithAL1M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dataWithAL1M);
+
+   invokeEndElement (pctxt, "dataWithAL1M", -1);
+
+   /* decode dataWithAL2M */
+
+   invokeStartElement (pctxt, "dataWithAL2M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dataWithAL2M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dataWithAL2M);
+
+   invokeEndElement (pctxt, "dataWithAL2M", -1);
+
+   /* decode dataWithAL3M */
+
+   invokeStartElement (pctxt, "dataWithAL3M", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dataWithAL3M);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dataWithAL3M);
+
+   invokeEndElement (pctxt, "dataWithAL3M", -1);
+
+   /* decode alpduInterleaving */
+
+   invokeStartElement (pctxt, "alpduInterleaving", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->alpduInterleaving);
+
+   invokeEndElement (pctxt, "alpduInterleaving", -1);
+
+   /* decode maximumAL1MPDUSize */
+
+   invokeStartElement (pctxt, "maximumAL1MPDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL1MPDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumAL1MPDUSize);
+
+   invokeEndElement (pctxt, "maximumAL1MPDUSize", -1);
+
+   /* decode maximumAL2MSDUSize */
+
+   invokeStartElement (pctxt, "maximumAL2MSDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL2MSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumAL2MSDUSize);
+
+   invokeEndElement (pctxt, "maximumAL2MSDUSize", -1);
+
+   /* decode maximumAL3MSDUSize */
+
+   invokeStartElement (pctxt, "maximumAL3MSDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL3MSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumAL3MSDUSize);
+
+   invokeEndElement (pctxt, "maximumAL3MSDUSize", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.rsCodeCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "rsCodeCapability", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->rsCodeCapability);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->rsCodeCapability);
+
+                     invokeEndElement (pctxt, "rsCodeCapability", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_mobileMultilinkFrameCapability             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode maximumSampleSize */
+
+   invokeStartElement (pctxt, "maximumSampleSize", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->maximumSampleSize, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumSampleSize);
+
+   invokeEndElement (pctxt, "maximumSampleSize", -1);
+
+   /* decode maximumPayloadLength */
+
+   invokeStartElement (pctxt, "maximumPayloadLength", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumPayloadLength, 1U, 65025U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumPayloadLength);
+
+   invokeEndElement (pctxt, "maximumPayloadLength", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode transportWithI_frames */
+
+   invokeStartElement (pctxt, "transportWithI_frames", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->transportWithI_frames);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->transportWithI_frames);
+
+   invokeEndElement (pctxt, "transportWithI_frames", -1);
+
+   /* decode videoWithAL1 */
+
+   invokeStartElement (pctxt, "videoWithAL1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->videoWithAL1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->videoWithAL1);
+
+   invokeEndElement (pctxt, "videoWithAL1", -1);
+
+   /* decode videoWithAL2 */
+
+   invokeStartElement (pctxt, "videoWithAL2", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->videoWithAL2);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->videoWithAL2);
+
+   invokeEndElement (pctxt, "videoWithAL2", -1);
+
+   /* decode videoWithAL3 */
+
+   invokeStartElement (pctxt, "videoWithAL3", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->videoWithAL3);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->videoWithAL3);
+
+   invokeEndElement (pctxt, "videoWithAL3", -1);
+
+   /* decode audioWithAL1 */
+
+   invokeStartElement (pctxt, "audioWithAL1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioWithAL1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioWithAL1);
+
+   invokeEndElement (pctxt, "audioWithAL1", -1);
+
+   /* decode audioWithAL2 */
+
+   invokeStartElement (pctxt, "audioWithAL2", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioWithAL2);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioWithAL2);
+
+   invokeEndElement (pctxt, "audioWithAL2", -1);
+
+   /* decode audioWithAL3 */
+
+   invokeStartElement (pctxt, "audioWithAL3", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioWithAL3);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioWithAL3);
+
+   invokeEndElement (pctxt, "audioWithAL3", -1);
+
+   /* decode dataWithAL1 */
+
+   invokeStartElement (pctxt, "dataWithAL1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dataWithAL1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dataWithAL1);
+
+   invokeEndElement (pctxt, "dataWithAL1", -1);
+
+   /* decode dataWithAL2 */
+
+   invokeStartElement (pctxt, "dataWithAL2", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dataWithAL2);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dataWithAL2);
+
+   invokeEndElement (pctxt, "dataWithAL2", -1);
+
+   /* decode dataWithAL3 */
+
+   invokeStartElement (pctxt, "dataWithAL3", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dataWithAL3);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dataWithAL3);
+
+   invokeEndElement (pctxt, "dataWithAL3", -1);
+
+   /* decode maximumAl2SDUSize */
+
+   invokeStartElement (pctxt, "maximumAl2SDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumAl2SDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumAl2SDUSize);
+
+   invokeEndElement (pctxt, "maximumAl2SDUSize", -1);
+
+   /* decode maximumAl3SDUSize */
+
+   invokeStartElement (pctxt, "maximumAl3SDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumAl3SDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumAl3SDUSize);
+
+   invokeEndElement (pctxt, "maximumAl3SDUSize", -1);
+
+   /* decode maximumDelayJitter */
+
+   invokeStartElement (pctxt, "maximumDelayJitter", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumDelayJitter, 0U, 1023U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumDelayJitter);
+
+   invokeEndElement (pctxt, "maximumDelayJitter", -1);
+
+   /* decode h223MultiplexTableCapability */
+
+   invokeStartElement (pctxt, "h223MultiplexTableCapability", -1);
+
+   stat = asn1PD_H245H223Capability_h223MultiplexTableCapability (pctxt, &pvalue->h223MultiplexTableCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "h223MultiplexTableCapability", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 6 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.maxMUXPDUSizeCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "maxMUXPDUSizeCapability", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->maxMUXPDUSizeCapability);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->maxMUXPDUSizeCapability);
+
+                     invokeEndElement (pctxt, "maxMUXPDUSizeCapability", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.nsrpSupportPresent = 1;
+
+                     invokeStartElement (pctxt, "nsrpSupport", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->nsrpSupport);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->nsrpSupport);
+
+                     invokeEndElement (pctxt, "nsrpSupport", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.mobileOperationTransmitCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "mobileOperationTransmitCapability", -1);
+
+                     stat = asn1PD_H245H223Capability_mobileOperationTransmitCapability (pctxt, &pvalue->mobileOperationTransmitCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "mobileOperationTransmitCapability", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.h223AnnexCCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "h223AnnexCCapability", -1);
+
+                     stat = asn1PD_H245H223AnnexCCapability (pctxt, &pvalue->h223AnnexCCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h223AnnexCCapability", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.bitRatePresent = 1;
+
+                     invokeStartElement (pctxt, "bitRate", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 19200U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->bitRate);
+
+                     invokeEndElement (pctxt, "bitRate", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.mobileMultilinkFrameCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "mobileMultilinkFrameCapability", -1);
+
+                     stat = asn1PD_H245H223Capability_mobileMultilinkFrameCapability (pctxt, &pvalue->mobileMultilinkFrameCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "mobileMultilinkFrameCapability", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V75Capability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode audioHeader */
+
+   invokeStartElement (pctxt, "audioHeader", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioHeader);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioHeader);
+
+   invokeEndElement (pctxt, "audioHeader", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76Capability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode suspendResumeCapabilitywAddress */
+
+   invokeStartElement (pctxt, "suspendResumeCapabilitywAddress", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->suspendResumeCapabilitywAddress);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->suspendResumeCapabilitywAddress);
+
+   invokeEndElement (pctxt, "suspendResumeCapabilitywAddress", -1);
+
+   /* decode suspendResumeCapabilitywoAddress */
+
+   invokeStartElement (pctxt, "suspendResumeCapabilitywoAddress", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->suspendResumeCapabilitywoAddress);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->suspendResumeCapabilitywoAddress);
+
+   invokeEndElement (pctxt, "suspendResumeCapabilitywoAddress", -1);
+
+   /* decode rejCapability */
+
+   invokeStartElement (pctxt, "rejCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->rejCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->rejCapability);
+
+   invokeEndElement (pctxt, "rejCapability", -1);
+
+   /* decode sREJCapability */
+
+   invokeStartElement (pctxt, "sREJCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->sREJCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->sREJCapability);
+
+   invokeEndElement (pctxt, "sREJCapability", -1);
+
+   /* decode mREJCapability */
+
+   invokeStartElement (pctxt, "mREJCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->mREJCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->mREJCapability);
+
+   invokeEndElement (pctxt, "mREJCapability", -1);
+
+   /* decode crc8bitCapability */
+
+   invokeStartElement (pctxt, "crc8bitCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->crc8bitCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->crc8bitCapability);
+
+   invokeEndElement (pctxt, "crc8bitCapability", -1);
+
+   /* decode crc16bitCapability */
+
+   invokeStartElement (pctxt, "crc16bitCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->crc16bitCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->crc16bitCapability);
+
+   invokeEndElement (pctxt, "crc16bitCapability", -1);
+
+   /* decode crc32bitCapability */
+
+   invokeStartElement (pctxt, "crc32bitCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->crc32bitCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->crc32bitCapability);
+
+   invokeEndElement (pctxt, "crc32bitCapability", -1);
+
+   /* decode uihCapability */
+
+   invokeStartElement (pctxt, "uihCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->uihCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->uihCapability);
+
+   invokeEndElement (pctxt, "uihCapability", -1);
+
+   /* decode numOfDLCS */
+
+   invokeStartElement (pctxt, "numOfDLCS", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->numOfDLCS, 2U, 8191U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numOfDLCS);
+
+   invokeEndElement (pctxt, "numOfDLCS", -1);
+
+   /* decode twoOctetAddressFieldCapability */
+
+   invokeStartElement (pctxt, "twoOctetAddressFieldCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->twoOctetAddressFieldCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->twoOctetAddressFieldCapability);
+
+   invokeEndElement (pctxt, "twoOctetAddressFieldCapability", -1);
+
+   /* decode loopBackTestCapability */
+
+   invokeStartElement (pctxt, "loopBackTestCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->loopBackTestCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->loopBackTestCapability);
+
+   invokeEndElement (pctxt, "loopBackTestCapability", -1);
+
+   /* decode n401Capability */
+
+   invokeStartElement (pctxt, "n401Capability", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->n401Capability, 1U, 4095U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->n401Capability);
+
+   invokeEndElement (pctxt, "n401Capability", -1);
+
+   /* decode maxWindowSizeCapability */
+
+   invokeStartElement (pctxt, "maxWindowSizeCapability", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->maxWindowSizeCapability, 1U, 127U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxWindowSizeCapability);
+
+   invokeEndElement (pctxt, "maxWindowSizeCapability", -1);
+
+   /* decode v75Capability */
+
+   invokeStartElement (pctxt, "v75Capability", -1);
+
+   stat = asn1PD_H245V75Capability (pctxt, &pvalue->v75Capability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "v75Capability", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T84Profile_t84Restricted                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode qcif */
+
+   invokeStartElement (pctxt, "qcif", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->qcif);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->qcif);
+
+   invokeEndElement (pctxt, "qcif", -1);
+
+   /* decode cif */
+
+   invokeStartElement (pctxt, "cif", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->cif);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->cif);
+
+   invokeEndElement (pctxt, "cif", -1);
+
+   /* decode ccir601Seq */
+
+   invokeStartElement (pctxt, "ccir601Seq", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->ccir601Seq);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->ccir601Seq);
+
+   invokeEndElement (pctxt, "ccir601Seq", -1);
+
+   /* decode ccir601Prog */
+
+   invokeStartElement (pctxt, "ccir601Prog", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->ccir601Prog);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->ccir601Prog);
+
+   invokeEndElement (pctxt, "ccir601Prog", -1);
+
+   /* decode hdtvSeq */
+
+   invokeStartElement (pctxt, "hdtvSeq", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->hdtvSeq);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->hdtvSeq);
+
+   invokeEndElement (pctxt, "hdtvSeq", -1);
+
+   /* decode hdtvProg */
+
+   invokeStartElement (pctxt, "hdtvProg", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->hdtvProg);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->hdtvProg);
+
+   invokeEndElement (pctxt, "hdtvProg", -1);
+
+   /* decode g3FacsMH200x100 */
+
+   invokeStartElement (pctxt, "g3FacsMH200x100", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->g3FacsMH200x100);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->g3FacsMH200x100);
+
+   invokeEndElement (pctxt, "g3FacsMH200x100", -1);
+
+   /* decode g3FacsMH200x200 */
+
+   invokeStartElement (pctxt, "g3FacsMH200x200", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->g3FacsMH200x200);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->g3FacsMH200x200);
+
+   invokeEndElement (pctxt, "g3FacsMH200x200", -1);
+
+   /* decode g4FacsMMR200x100 */
+
+   invokeStartElement (pctxt, "g4FacsMMR200x100", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->g4FacsMMR200x100);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->g4FacsMMR200x100);
+
+   invokeEndElement (pctxt, "g4FacsMMR200x100", -1);
+
+   /* decode g4FacsMMR200x200 */
+
+   invokeStartElement (pctxt, "g4FacsMMR200x200", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->g4FacsMMR200x200);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->g4FacsMMR200x200);
+
+   invokeEndElement (pctxt, "g4FacsMMR200x200", -1);
+
+   /* decode jbig200x200Seq */
+
+   invokeStartElement (pctxt, "jbig200x200Seq", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->jbig200x200Seq);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->jbig200x200Seq);
+
+   invokeEndElement (pctxt, "jbig200x200Seq", -1);
+
+   /* decode jbig200x200Prog */
+
+   invokeStartElement (pctxt, "jbig200x200Prog", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->jbig200x200Prog);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->jbig200x200Prog);
+
+   invokeEndElement (pctxt, "jbig200x200Prog", -1);
+
+   /* decode jbig300x300Seq */
+
+   invokeStartElement (pctxt, "jbig300x300Seq", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->jbig300x300Seq);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->jbig300x300Seq);
+
+   invokeEndElement (pctxt, "jbig300x300Seq", -1);
+
+   /* decode jbig300x300Prog */
+
+   invokeStartElement (pctxt, "jbig300x300Prog", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->jbig300x300Prog);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->jbig300x300Prog);
+
+   invokeEndElement (pctxt, "jbig300x300Prog", -1);
+
+   /* decode digPhotoLow */
+
+   invokeStartElement (pctxt, "digPhotoLow", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->digPhotoLow);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->digPhotoLow);
+
+   invokeEndElement (pctxt, "digPhotoLow", -1);
+
+   /* decode digPhotoMedSeq */
+
+   invokeStartElement (pctxt, "digPhotoMedSeq", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->digPhotoMedSeq);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->digPhotoMedSeq);
+
+   invokeEndElement (pctxt, "digPhotoMedSeq", -1);
+
+   /* decode digPhotoMedProg */
+
+   invokeStartElement (pctxt, "digPhotoMedProg", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->digPhotoMedProg);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->digPhotoMedProg);
+
+   invokeEndElement (pctxt, "digPhotoMedProg", -1);
+
+   /* decode digPhotoHighSeq */
+
+   invokeStartElement (pctxt, "digPhotoHighSeq", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->digPhotoHighSeq);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->digPhotoHighSeq);
+
+   invokeEndElement (pctxt, "digPhotoHighSeq", -1);
+
+   /* decode digPhotoHighProg */
+
+   invokeStartElement (pctxt, "digPhotoHighProg", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->digPhotoHighProg);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->digPhotoHighProg);
+
+   invokeEndElement (pctxt, "digPhotoHighProg", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T84Profile                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245T84Profile (OOCTXT* pctxt, H245T84Profile* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* t84Unrestricted */
+      case 0:
+         invokeStartElement (pctxt, "t84Unrestricted", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "t84Unrestricted", -1);
+
+         break;
+
+      /* t84Restricted */
+      case 1:
+         invokeStartElement (pctxt, "t84Restricted", -1);
+
+         pvalue->u.t84Restricted = ALLOC_ASN1ELEM (pctxt, H245T84Profile_t84Restricted);
+
+         stat = asn1PD_H245T84Profile_t84Restricted (pctxt, pvalue->u.t84Restricted);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "t84Restricted", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_t84                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataApplicationCapability_application_t84 (OOCTXT* pctxt, H245DataApplicationCapability_application_t84* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode t84Protocol */
+
+   invokeStartElement (pctxt, "t84Protocol", -1);
+
+   stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->t84Protocol);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t84Protocol", -1);
+
+   /* decode t84Profile */
+
+   invokeStartElement (pctxt, "t84Profile", -1);
+
+   stat = asn1PD_H245T84Profile (pctxt, &pvalue->t84Profile);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t84Profile", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_nlpid               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataApplicationCapability_application_nlpid (OOCTXT* pctxt, H245DataApplicationCapability_application_nlpid* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode nlpidProtocol */
+
+   invokeStartElement (pctxt, "nlpidProtocol", -1);
+
+   stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->nlpidProtocol);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nlpidProtocol", -1);
+
+   /* decode nlpidData */
+
+   invokeStartElement (pctxt, "nlpidData", -1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->nlpidData);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->nlpidData.numocts, pvalue->nlpidData.data);
+
+   invokeEndElement (pctxt, "nlpidData", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_t38fax              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataApplicationCapability_application_t38fax (OOCTXT* pctxt, H245DataApplicationCapability_application_t38fax* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode t38FaxProtocol */
+
+   invokeStartElement (pctxt, "t38FaxProtocol", -1);
+
+   stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t38FaxProtocol", -1);
+
+   /* decode t38FaxProfile */
+
+   invokeStartElement (pctxt, "t38FaxProfile", -1);
+
+   stat = asn1PD_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t38FaxProfile", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityIdentifier_uuid                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CapabilityIdentifier_uuid (OOCTXT* pctxt, H245CapabilityIdentifier_uuid* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CapabilityIdentifier (OOCTXT* pctxt, H245CapabilityIdentifier* pvalue)
+{
+   static Asn1SizeCnst domainBased_lsize1 = { 0, 1, 64, 0 };
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* standard */
+         case 0:
+            invokeStartElement (pctxt, "standard", -1);
+
+            pvalue->u.standard = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.standard);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.standard->numids, pvalue->u.standard->subid);
+
+            invokeEndElement (pctxt, "standard", -1);
+
+            break;
+
+         /* h221NonStandard */
+         case 1:
+            invokeStartElement (pctxt, "h221NonStandard", -1);
+
+            pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.h221NonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h221NonStandard", -1);
+
+            break;
+
+         /* uuid */
+         case 2:
+            invokeStartElement (pctxt, "uuid", -1);
+
+            pvalue->u.uuid = ALLOC_ASN1ELEM (pctxt, H245CapabilityIdentifier_uuid);
+
+            stat = asn1PD_H245CapabilityIdentifier_uuid (pctxt, pvalue->u.uuid);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "uuid", -1);
+
+            break;
+
+         /* domainBased */
+         case 3:
+            invokeStartElement (pctxt, "domainBased", -1);
+
+            addSizeConstraint (pctxt, &domainBased_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.domainBased, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.domainBased);
+
+            invokeEndElement (pctxt, "domainBased", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterIdentifier_uuid                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ParameterIdentifier_uuid (OOCTXT* pctxt, H245ParameterIdentifier_uuid* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterIdentifier                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ParameterIdentifier (OOCTXT* pctxt, H245ParameterIdentifier* pvalue)
+{
+   static Asn1SizeCnst domainBased_lsize1 = { 0, 1, 64, 0 };
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* standard */
+         case 0:
+            invokeStartElement (pctxt, "standard", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.standard, 0U, 127U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.standard);
+
+            invokeEndElement (pctxt, "standard", -1);
+
+            break;
+
+         /* h221NonStandard */
+         case 1:
+            invokeStartElement (pctxt, "h221NonStandard", -1);
+
+            pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.h221NonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h221NonStandard", -1);
+
+            break;
+
+         /* uuid */
+         case 2:
+            invokeStartElement (pctxt, "uuid", -1);
+
+            pvalue->u.uuid = ALLOC_ASN1ELEM (pctxt, H245ParameterIdentifier_uuid);
+
+            stat = asn1PD_H245ParameterIdentifier_uuid (pctxt, pvalue->u.uuid);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "uuid", -1);
+
+            break;
+
+         /* domainBased */
+         case 3:
+            invokeStartElement (pctxt, "domainBased", -1);
+
+            addSizeConstraint (pctxt, &domainBased_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.domainBased, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.domainBased);
+
+            invokeEndElement (pctxt, "domainBased", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterValue                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ParameterValue (OOCTXT* pctxt, H245ParameterValue* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* logical */
+         case 0:
+            invokeStartElement (pctxt, "logical", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "logical", -1);
+
+            break;
+
+         /* booleanArray */
+         case 1:
+            invokeStartElement (pctxt, "booleanArray", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.booleanArray, 0U, 255U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.booleanArray);
+
+            invokeEndElement (pctxt, "booleanArray", -1);
+
+            break;
+
+         /* unsignedMin */
+         case 2:
+            invokeStartElement (pctxt, "unsignedMin", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.unsignedMin, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.unsignedMin);
+
+            invokeEndElement (pctxt, "unsignedMin", -1);
+
+            break;
+
+         /* unsignedMax */
+         case 3:
+            invokeStartElement (pctxt, "unsignedMax", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.unsignedMax, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.unsignedMax);
+
+            invokeEndElement (pctxt, "unsignedMax", -1);
+
+            break;
+
+         /* unsigned32Min */
+         case 4:
+            invokeStartElement (pctxt, "unsigned32Min", -1);
+
+            stat = decodeConsUnsigned (pctxt, &pvalue->u.unsigned32Min, 0U, ASN1UINT_MAX);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.unsigned32Min);
+
+            invokeEndElement (pctxt, "unsigned32Min", -1);
+
+            break;
+
+         /* unsigned32Max */
+         case 5:
+            invokeStartElement (pctxt, "unsigned32Max", -1);
+
+            stat = decodeConsUnsigned (pctxt, &pvalue->u.unsigned32Max, 0U, ASN1UINT_MAX);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.unsigned32Max);
+
+            invokeEndElement (pctxt, "unsigned32Max", -1);
+
+            break;
+
+         /* octetString */
+         case 6:
+            invokeStartElement (pctxt, "octetString", -1);
+
+            pvalue->u.octetString = ALLOC_ASN1ELEM (pctxt, ASN1DynOctStr);
+
+            stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue->u.octetString);
+            if (stat != ASN_OK) return stat;
+            invokeOctStrValue (pctxt, pvalue->u.octetString->numocts, pvalue->u.octetString->data);
+
+            invokeEndElement (pctxt, "octetString", -1);
+
+            break;
+
+         /* genericParameter */
+         case 7:
+            invokeStartElement (pctxt, "genericParameter", -1);
+
+            pvalue->u.genericParameter = ALLOC_ASN1ELEM (pctxt, H245_SeqOfH245GenericParameter);
+
+            stat = asn1PD_H245_SeqOfH245GenericParameter (pctxt, (H245_SeqOfH245GenericParameter*)pvalue->u.genericParameter);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericParameter", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 9;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245ParameterIdentifier                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245ParameterIdentifier (OOCTXT* pctxt, H245_SeqOfH245ParameterIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   H245ParameterIdentifier* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245ParameterIdentifier);
+
+         stat = asn1PD_H245ParameterIdentifier (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericParameter                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245GenericParameter (OOCTXT* pctxt, H245GenericParameter* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.supersedesPresent = optbit;
+
+   /* decode parameterIdentifier */
+
+   invokeStartElement (pctxt, "parameterIdentifier", -1);
+
+   stat = asn1PD_H245ParameterIdentifier (pctxt, &pvalue->parameterIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "parameterIdentifier", -1);
+
+   /* decode parameterValue */
+
+   invokeStartElement (pctxt, "parameterValue", -1);
+
+   stat = asn1PD_H245ParameterValue (pctxt, &pvalue->parameterValue);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "parameterValue", -1);
+
+   /* decode supersedes */
+
+   if (pvalue->m.supersedesPresent) {
+      invokeStartElement (pctxt, "supersedes", -1);
+
+      stat = asn1PD_H245_SeqOfH245ParameterIdentifier (pctxt, &pvalue->supersedes);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "supersedes", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245GenericParameter                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245GenericParameter (OOCTXT* pctxt, H245_SeqOfH245GenericParameter* pvalue)
+{
+   int stat = ASN_OK;
+   H245GenericParameter* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245GenericParameter);
+
+         stat = asn1PD_H245GenericParameter (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericCapability                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245GenericCapability (OOCTXT* pctxt, H245GenericCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.maxBitRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.collapsingPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonCollapsingPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonCollapsingRawPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.transportPresent = optbit;
+
+   /* decode capabilityIdentifier */
+
+   invokeStartElement (pctxt, "capabilityIdentifier", -1);
+
+   stat = asn1PD_H245CapabilityIdentifier (pctxt, &pvalue->capabilityIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "capabilityIdentifier", -1);
+
+   /* decode maxBitRate */
+
+   if (pvalue->m.maxBitRatePresent) {
+      invokeStartElement (pctxt, "maxBitRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->maxBitRate, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->maxBitRate);
+
+      invokeEndElement (pctxt, "maxBitRate", -1);
+   }
+
+   /* decode collapsing */
+
+   if (pvalue->m.collapsingPresent) {
+      invokeStartElement (pctxt, "collapsing", -1);
+
+      stat = asn1PD_H245_SeqOfH245GenericParameter (pctxt, &pvalue->collapsing);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "collapsing", -1);
+   }
+
+   /* decode nonCollapsing */
+
+   if (pvalue->m.nonCollapsingPresent) {
+      invokeStartElement (pctxt, "nonCollapsing", -1);
+
+      stat = asn1PD_H245_SeqOfH245GenericParameter (pctxt, &pvalue->nonCollapsing);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonCollapsing", -1);
+   }
+
+   /* decode nonCollapsingRaw */
+
+   if (pvalue->m.nonCollapsingRawPresent) {
+      invokeStartElement (pctxt, "nonCollapsingRaw", -1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->nonCollapsingRaw);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->nonCollapsingRaw.numocts, pvalue->nonCollapsingRaw.data);
+
+      invokeEndElement (pctxt, "nonCollapsingRaw", -1);
+   }
+
+   /* decode transport */
+
+   if (pvalue->m.transportPresent) {
+      invokeStartElement (pctxt, "transport", -1);
+
+      stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->transport);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "transport", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataApplicationCapability_application (OOCTXT* pctxt, H245DataApplicationCapability_application* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 9);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* t120 */
+         case 1:
+            invokeStartElement (pctxt, "t120", -1);
+
+            pvalue->u.t120 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t120);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t120", -1);
+
+            break;
+
+         /* dsm_cc */
+         case 2:
+            invokeStartElement (pctxt, "dsm_cc", -1);
+
+            pvalue->u.dsm_cc = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.dsm_cc);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "dsm_cc", -1);
+
+            break;
+
+         /* userData */
+         case 3:
+            invokeStartElement (pctxt, "userData", -1);
+
+            pvalue->u.userData = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.userData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "userData", -1);
+
+            break;
+
+         /* t84 */
+         case 4:
+            invokeStartElement (pctxt, "t84", -1);
+
+            pvalue->u.t84 = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability_application_t84);
+
+            stat = asn1PD_H245DataApplicationCapability_application_t84 (pctxt, pvalue->u.t84);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t84", -1);
+
+            break;
+
+         /* t434 */
+         case 5:
+            invokeStartElement (pctxt, "t434", -1);
+
+            pvalue->u.t434 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t434);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t434", -1);
+
+            break;
+
+         /* h224 */
+         case 6:
+            invokeStartElement (pctxt, "h224", -1);
+
+            pvalue->u.h224 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.h224);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h224", -1);
+
+            break;
+
+         /* nlpid */
+         case 7:
+            invokeStartElement (pctxt, "nlpid", -1);
+
+            pvalue->u.nlpid = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability_application_nlpid);
+
+            stat = asn1PD_H245DataApplicationCapability_application_nlpid (pctxt, pvalue->u.nlpid);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nlpid", -1);
+
+            break;
+
+         /* dsvdControl */
+         case 8:
+            invokeStartElement (pctxt, "dsvdControl", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "dsvdControl", -1);
+
+            break;
+
+         /* h222DataPartitioning */
+         case 9:
+            invokeStartElement (pctxt, "h222DataPartitioning", -1);
+
+            pvalue->u.h222DataPartitioning = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.h222DataPartitioning);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h222DataPartitioning", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 11;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* t30fax */
+         case 11:
+            invokeStartElement (pctxt, "t30fax", -1);
+
+            pvalue->u.t30fax = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t30fax);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t30fax", -1);
+
+            break;
+
+         /* t140 */
+         case 12:
+            invokeStartElement (pctxt, "t140", -1);
+
+            pvalue->u.t140 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t140);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t140", -1);
+
+            break;
+
+         /* t38fax */
+         case 13:
+            invokeStartElement (pctxt, "t38fax", -1);
+
+            pvalue->u.t38fax = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability_application_t38fax);
+
+            stat = asn1PD_H245DataApplicationCapability_application_t38fax (pctxt, pvalue->u.t38fax);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t38fax", -1);
+
+            break;
+
+         /* genericDataCapability */
+         case 14:
+            invokeStartElement (pctxt, "genericDataCapability", -1);
+
+            pvalue->u.genericDataCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability);
+
+            stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericDataCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericDataCapability", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataApplicationCapability (OOCTXT* pctxt, H245DataApplicationCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode application */
+
+   invokeStartElement (pctxt, "application", -1);
+
+   stat = asn1PD_H245DataApplicationCapability_application (pctxt, &pvalue->application);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "application", -1);
+
+   /* decode maxBitRate */
+
+   invokeStartElement (pctxt, "maxBitRate", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->maxBitRate, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxBitRate);
+
+   invokeEndElement (pctxt, "maxBitRate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245DataApplicationCapability                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245DataApplicationCapability (OOCTXT* pctxt, H245_SeqOfH245DataApplicationCapability* pvalue)
+{
+   int stat = ASN_OK;
+   H245DataApplicationCapability* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245DataApplicationCapability);
+
+         stat = asn1PD_H245DataApplicationCapability (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaDistributionCapability                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MediaDistributionCapability (OOCTXT* pctxt, H245MediaDistributionCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.centralizedDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.distributedDataPresent = optbit;
+
+   /* decode centralizedControl */
+
+   invokeStartElement (pctxt, "centralizedControl", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->centralizedControl);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->centralizedControl);
+
+   invokeEndElement (pctxt, "centralizedControl", -1);
+
+   /* decode distributedControl */
+
+   invokeStartElement (pctxt, "distributedControl", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->distributedControl);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->distributedControl);
+
+   invokeEndElement (pctxt, "distributedControl", -1);
+
+   /* decode centralizedAudio */
+
+   invokeStartElement (pctxt, "centralizedAudio", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->centralizedAudio);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->centralizedAudio);
+
+   invokeEndElement (pctxt, "centralizedAudio", -1);
+
+   /* decode distributedAudio */
+
+   invokeStartElement (pctxt, "distributedAudio", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->distributedAudio);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->distributedAudio);
+
+   invokeEndElement (pctxt, "distributedAudio", -1);
+
+   /* decode centralizedVideo */
+
+   invokeStartElement (pctxt, "centralizedVideo", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->centralizedVideo);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->centralizedVideo);
+
+   invokeEndElement (pctxt, "centralizedVideo", -1);
+
+   /* decode distributedVideo */
+
+   invokeStartElement (pctxt, "distributedVideo", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->distributedVideo);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->distributedVideo);
+
+   invokeEndElement (pctxt, "distributedVideo", -1);
+
+   /* decode centralizedData */
+
+   if (pvalue->m.centralizedDataPresent) {
+      invokeStartElement (pctxt, "centralizedData", -1);
+
+      stat = asn1PD_H245_SeqOfH245DataApplicationCapability (pctxt, &pvalue->centralizedData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "centralizedData", -1);
+   }
+
+   /* decode distributedData */
+
+   if (pvalue->m.distributedDataPresent) {
+      invokeStartElement (pctxt, "distributedData", -1);
+
+      stat = asn1PD_H245_SeqOfH245DataApplicationCapability (pctxt, &pvalue->distributedData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "distributedData", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MediaDistributionCapability                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245MediaDistributionCapability (OOCTXT* pctxt, H245_SeqOfH245MediaDistributionCapability* pvalue)
+{
+   int stat = ASN_OK;
+   H245MediaDistributionCapability* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MediaDistributionCapability);
+
+         stat = asn1PD_H245MediaDistributionCapability (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultipointCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultipointCapability (OOCTXT* pctxt, H245MultipointCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode multicastCapability */
+
+   invokeStartElement (pctxt, "multicastCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->multicastCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->multicastCapability);
+
+   invokeEndElement (pctxt, "multicastCapability", -1);
+
+   /* decode multiUniCastConference */
+
+   invokeStartElement (pctxt, "multiUniCastConference", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->multiUniCastConference);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->multiUniCastConference);
+
+   invokeEndElement (pctxt, "multiUniCastConference", -1);
+
+   /* decode mediaDistributionCapability */
+
+   invokeStartElement (pctxt, "mediaDistributionCapability", -1);
+
+   stat = asn1PD_H245_SeqOfH245MediaDistributionCapability (pctxt, &pvalue->mediaDistributionCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mediaDistributionCapability", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability_mcCapability                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H2250Capability_mcCapability (OOCTXT* pctxt, H245H2250Capability_mcCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode centralizedConferenceMC */
+
+   invokeStartElement (pctxt, "centralizedConferenceMC", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->centralizedConferenceMC);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->centralizedConferenceMC);
+
+   invokeEndElement (pctxt, "centralizedConferenceMC", -1);
+
+   /* decode decentralizedConferenceMC */
+
+   invokeStartElement (pctxt, "decentralizedConferenceMC", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->decentralizedConferenceMC);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->decentralizedConferenceMC);
+
+   invokeEndElement (pctxt, "decentralizedConferenceMC", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPPayloadType_payloadDescriptor                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RTPPayloadType_payloadDescriptor (OOCTXT* pctxt, H245RTPPayloadType_payloadDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandardIdentifier */
+         case 0:
+            invokeStartElement (pctxt, "nonStandardIdentifier", -1);
+
+            pvalue->u.nonStandardIdentifier = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandardIdentifier);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandardIdentifier", -1);
+
+            break;
+
+         /* rfc_number */
+         case 1:
+            invokeStartElement (pctxt, "rfc_number", -1);
+
+            /* extension bit */
+
+            DECODEBIT (pctxt, &extbit);
+
+            if (extbit == 0) {
+               stat = decodeConsInteger (pctxt, &pvalue->u.rfc_number, 1, 32768);
+               if (stat != ASN_OK) return stat;
+            }
+            else {
+               stat = decodeUnconsInteger (pctxt, &pvalue->u.rfc_number);
+               if (stat != ASN_OK) return stat;
+            }
+            invokeIntValue (pctxt, pvalue->u.rfc_number);
+
+            invokeEndElement (pctxt, "rfc_number", -1);
+
+            break;
+
+         /* oid */
+         case 2:
+            invokeStartElement (pctxt, "oid", -1);
+
+            pvalue->u.oid = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.oid);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.oid->numids, pvalue->u.oid->subid);
+
+            invokeEndElement (pctxt, "oid", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPPayloadType                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RTPPayloadType (OOCTXT* pctxt, H245RTPPayloadType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.payloadTypePresent = optbit;
+
+   /* decode payloadDescriptor */
+
+   invokeStartElement (pctxt, "payloadDescriptor", -1);
+
+   stat = asn1PD_H245RTPPayloadType_payloadDescriptor (pctxt, &pvalue->payloadDescriptor);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "payloadDescriptor", -1);
+
+   /* decode payloadType */
+
+   if (pvalue->m.payloadTypePresent) {
+      invokeStartElement (pctxt, "payloadType", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->payloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->payloadType);
+
+      invokeEndElement (pctxt, "payloadType", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaPacketizationCapability_rtpPayloadType               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MediaPacketizationCapability_rtpPayloadType (OOCTXT* pctxt, H245MediaPacketizationCapability_rtpPayloadType* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245RTPPayloadType* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245RTPPayloadType);
+
+      stat = asn1PD_H245RTPPayloadType (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaPacketizationCapability                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MediaPacketizationCapability (OOCTXT* pctxt, H245MediaPacketizationCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode h261aVideoPacketization */
+
+   invokeStartElement (pctxt, "h261aVideoPacketization", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->h261aVideoPacketization);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->h261aVideoPacketization);
+
+   invokeEndElement (pctxt, "h261aVideoPacketization", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.rtpPayloadTypePresent = 1;
+
+                     invokeStartElement (pctxt, "rtpPayloadType", -1);
+
+                     stat = asn1PD_H245MediaPacketizationCapability_rtpPayloadType (pctxt, &pvalue->rtpPayloadType);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "rtpPayloadType", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  QOSMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245QOSMode (OOCTXT* pctxt, H245QOSMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* guaranteedQOS */
+         case 0:
+            invokeStartElement (pctxt, "guaranteedQOS", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "guaranteedQOS", -1);
+
+            break;
+
+         /* controlledLoad */
+         case 1:
+            invokeStartElement (pctxt, "controlledLoad", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "controlledLoad", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RSVPParameters                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RSVPParameters (OOCTXT* pctxt, H245RSVPParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.qosModePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.tokenRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.bucketSizePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.peakRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.minPolicedPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.maxPktSizePresent = optbit;
+
+   /* decode qosMode */
+
+   if (pvalue->m.qosModePresent) {
+      invokeStartElement (pctxt, "qosMode", -1);
+
+      stat = asn1PD_H245QOSMode (pctxt, &pvalue->qosMode);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "qosMode", -1);
+   }
+
+   /* decode tokenRate */
+
+   if (pvalue->m.tokenRatePresent) {
+      invokeStartElement (pctxt, "tokenRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->tokenRate, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->tokenRate);
+
+      invokeEndElement (pctxt, "tokenRate", -1);
+   }
+
+   /* decode bucketSize */
+
+   if (pvalue->m.bucketSizePresent) {
+      invokeStartElement (pctxt, "bucketSize", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->bucketSize, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->bucketSize);
+
+      invokeEndElement (pctxt, "bucketSize", -1);
+   }
+
+   /* decode peakRate */
+
+   if (pvalue->m.peakRatePresent) {
+      invokeStartElement (pctxt, "peakRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->peakRate, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->peakRate);
+
+      invokeEndElement (pctxt, "peakRate", -1);
+   }
+
+   /* decode minPoliced */
+
+   if (pvalue->m.minPolicedPresent) {
+      invokeStartElement (pctxt, "minPoliced", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->minPoliced, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->minPoliced);
+
+      invokeEndElement (pctxt, "minPoliced", -1);
+   }
+
+   /* decode maxPktSize */
+
+   if (pvalue->m.maxPktSizePresent) {
+      invokeStartElement (pctxt, "maxPktSize", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->maxPktSize, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->maxPktSize);
+
+      invokeEndElement (pctxt, "maxPktSize", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ATMParameters                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ATMParameters (OOCTXT* pctxt, H245ATMParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode maxNTUSize */
+
+   invokeStartElement (pctxt, "maxNTUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maxNTUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxNTUSize);
+
+   invokeEndElement (pctxt, "maxNTUSize", -1);
+
+   /* decode atmUBR */
+
+   invokeStartElement (pctxt, "atmUBR", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->atmUBR);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->atmUBR);
+
+   invokeEndElement (pctxt, "atmUBR", -1);
+
+   /* decode atmrtVBR */
+
+   invokeStartElement (pctxt, "atmrtVBR", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->atmrtVBR);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->atmrtVBR);
+
+   invokeEndElement (pctxt, "atmrtVBR", -1);
+
+   /* decode atmnrtVBR */
+
+   invokeStartElement (pctxt, "atmnrtVBR", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->atmnrtVBR);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->atmnrtVBR);
+
+   invokeEndElement (pctxt, "atmnrtVBR", -1);
+
+   /* decode atmABR */
+
+   invokeStartElement (pctxt, "atmABR", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->atmABR);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->atmABR);
+
+   invokeEndElement (pctxt, "atmABR", -1);
+
+   /* decode atmCBR */
+
+   invokeStartElement (pctxt, "atmCBR", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->atmCBR);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->atmCBR);
+
+   invokeEndElement (pctxt, "atmCBR", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  QOSCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245QOSCapability (OOCTXT* pctxt, H245QOSCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.rsvpParametersPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.atmParametersPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode rsvpParameters */
+
+   if (pvalue->m.rsvpParametersPresent) {
+      invokeStartElement (pctxt, "rsvpParameters", -1);
+
+      stat = asn1PD_H245RSVPParameters (pctxt, &pvalue->rsvpParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "rsvpParameters", -1);
+   }
+
+   /* decode atmParameters */
+
+   if (pvalue->m.atmParametersPresent) {
+      invokeStartElement (pctxt, "atmParameters", -1);
+
+      stat = asn1PD_H245ATMParameters (pctxt, &pvalue->atmParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "atmParameters", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability_qOSCapabilities                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TransportCapability_qOSCapabilities (OOCTXT* pctxt, H245TransportCapability_qOSCapabilities* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245QOSCapability* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245QOSCapability);
+
+      stat = asn1PD_H245QOSCapability (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaTransportType_atm_AAL5_compressed                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MediaTransportType_atm_AAL5_compressed (OOCTXT* pctxt, H245MediaTransportType_atm_AAL5_compressed* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode variable_delta */
+
+   invokeStartElement (pctxt, "variable_delta", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->variable_delta);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->variable_delta);
+
+   invokeEndElement (pctxt, "variable_delta", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaTransportType                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MediaTransportType (OOCTXT* pctxt, H245MediaTransportType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* ip_UDP */
+         case 0:
+            invokeStartElement (pctxt, "ip_UDP", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "ip_UDP", -1);
+
+            break;
+
+         /* ip_TCP */
+         case 1:
+            invokeStartElement (pctxt, "ip_TCP", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "ip_TCP", -1);
+
+            break;
+
+         /* atm_AAL5_UNIDIR */
+         case 2:
+            invokeStartElement (pctxt, "atm_AAL5_UNIDIR", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "atm_AAL5_UNIDIR", -1);
+
+            break;
+
+         /* atm_AAL5_BIDIR */
+         case 3:
+            invokeStartElement (pctxt, "atm_AAL5_BIDIR", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "atm_AAL5_BIDIR", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* atm_AAL5_compressed */
+         case 5:
+            invokeStartElement (pctxt, "atm_AAL5_compressed", -1);
+
+            pvalue->u.atm_AAL5_compressed = ALLOC_ASN1ELEM (pctxt, H245MediaTransportType_atm_AAL5_compressed);
+
+            stat = asn1PD_H245MediaTransportType_atm_AAL5_compressed (pctxt, pvalue->u.atm_AAL5_compressed);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "atm_AAL5_compressed", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaChannelCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MediaChannelCapability (OOCTXT* pctxt, H245MediaChannelCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaTransportPresent = optbit;
+
+   /* decode mediaTransport */
+
+   if (pvalue->m.mediaTransportPresent) {
+      invokeStartElement (pctxt, "mediaTransport", -1);
+
+      stat = asn1PD_H245MediaTransportType (pctxt, &pvalue->mediaTransport);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaTransport", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability_mediaChannelCapabilities              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TransportCapability_mediaChannelCapabilities (OOCTXT* pctxt, H245TransportCapability_mediaChannelCapabilities* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245MediaChannelCapability* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MediaChannelCapability);
+
+      stat = asn1PD_H245MediaChannelCapability (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TransportCapability (OOCTXT* pctxt, H245TransportCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.qOSCapabilitiesPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaChannelCapabilitiesPresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   /* decode qOSCapabilities */
+
+   if (pvalue->m.qOSCapabilitiesPresent) {
+      invokeStartElement (pctxt, "qOSCapabilities", -1);
+
+      stat = asn1PD_H245TransportCapability_qOSCapabilities (pctxt, &pvalue->qOSCapabilities);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "qOSCapabilities", -1);
+   }
+
+   /* decode mediaChannelCapabilities */
+
+   if (pvalue->m.mediaChannelCapabilitiesPresent) {
+      invokeStartElement (pctxt, "mediaChannelCapabilities", -1);
+
+      stat = asn1PD_H245TransportCapability_mediaChannelCapabilities (pctxt, &pvalue->mediaChannelCapabilities);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaChannelCapabilities", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyFrameMapping_frameSequence          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyFrameMapping_frameSequence (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping_frameSequence* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->elem[xx1], 0U, 255U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->elem[xx1]);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyFrameMapping                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyFrameMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode threadNumber */
+
+   invokeStartElement (pctxt, "threadNumber", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->threadNumber, 0U, 15U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->threadNumber);
+
+   invokeEndElement (pctxt, "threadNumber", -1);
+
+   /* decode frameSequence */
+
+   invokeStartElement (pctxt, "frameSequence", -1);
+
+   stat = asn1PD_H245RTPH263VideoRedundancyFrameMapping_frameSequence (pctxt, &pvalue->frameSequence);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "frameSequence", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_frameToThreadMapping_cust  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245RTPH263VideoRedundancyFrameMapping* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245RTPH263VideoRedundancyFrameMapping);
+
+      stat = asn1PD_H245RTPH263VideoRedundancyFrameMapping (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_frameToThreadMapping       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* roundrobin */
+         case 0:
+            invokeStartElement (pctxt, "roundrobin", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "roundrobin", -1);
+
+            break;
+
+         /* custom */
+         case 1:
+            invokeStartElement (pctxt, "custom", -1);
+
+            pvalue->u.custom = ALLOC_ASN1ELEM (pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom);
+
+            stat = asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (pctxt, pvalue->u.custom);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "custom", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_containedThreads           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_containedThreads (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_containedThreads* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->elem[xx1], 0U, 15U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->elem[xx1]);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.containedThreadsPresent = optbit;
+
+   /* decode numberOfThreads */
+
+   invokeStartElement (pctxt, "numberOfThreads", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->numberOfThreads, 1U, 16U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfThreads);
+
+   invokeEndElement (pctxt, "numberOfThreads", -1);
+
+   /* decode framesBetweenSyncPoints */
+
+   invokeStartElement (pctxt, "framesBetweenSyncPoints", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->framesBetweenSyncPoints, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->framesBetweenSyncPoints);
+
+   invokeEndElement (pctxt, "framesBetweenSyncPoints", -1);
+
+   /* decode frameToThreadMapping */
+
+   invokeStartElement (pctxt, "frameToThreadMapping", -1);
+
+   stat = asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (pctxt, &pvalue->frameToThreadMapping);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "frameToThreadMapping", -1);
+
+   /* decode containedThreads */
+
+   if (pvalue->m.containedThreadsPresent) {
+      invokeStartElement (pctxt, "containedThreads", -1);
+
+      stat = asn1PD_H245RTPH263VideoRedundancyEncoding_containedThreads (pctxt, &pvalue->containedThreads);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "containedThreads", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMethod                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingMethod (OOCTXT* pctxt, H245RedundancyEncodingMethod* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* rtpAudioRedundancyEncoding */
+         case 1:
+            invokeStartElement (pctxt, "rtpAudioRedundancyEncoding", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "rtpAudioRedundancyEncoding", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* rtpH263VideoRedundancyEncoding */
+         case 3:
+            invokeStartElement (pctxt, "rtpH263VideoRedundancyEncoding", -1);
+
+            pvalue->u.rtpH263VideoRedundancyEncoding = ALLOC_ASN1ELEM (pctxt, H245RTPH263VideoRedundancyEncoding);
+
+            stat = asn1PD_H245RTPH263VideoRedundancyEncoding (pctxt, pvalue->u.rtpH263VideoRedundancyEncoding);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "rtpH263VideoRedundancyEncoding", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityTableEntryNumber                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CapabilityTableEntryNumber (OOCTXT* pctxt, H245CapabilityTableEntryNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt16 (pctxt, pvalue, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingCapability_secondaryEncoding            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingCapability_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingCapability_secondaryEncoding* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingCapability                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingCapability (OOCTXT* pctxt, H245RedundancyEncodingCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.secondaryEncodingPresent = optbit;
+
+   /* decode redundancyEncodingMethod */
+
+   invokeStartElement (pctxt, "redundancyEncodingMethod", -1);
+
+   stat = asn1PD_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "redundancyEncodingMethod", -1);
+
+   /* decode primaryEncoding */
+
+   invokeStartElement (pctxt, "primaryEncoding", -1);
+
+   stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->primaryEncoding);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "primaryEncoding", -1);
+
+   /* decode secondaryEncoding */
+
+   if (pvalue->m.secondaryEncodingPresent) {
+      invokeStartElement (pctxt, "secondaryEncoding", -1);
+
+      stat = asn1PD_H245RedundancyEncodingCapability_secondaryEncoding (pctxt, &pvalue->secondaryEncoding);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "secondaryEncoding", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability_redundancyEncodingCapability              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H2250Capability_redundancyEncodingCapability (OOCTXT* pctxt, H245H2250Capability_redundancyEncodingCapability* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245RedundancyEncodingCapability* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245RedundancyEncodingCapability);
+
+      stat = asn1PD_H245RedundancyEncodingCapability (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H2250Capability (OOCTXT* pctxt, H245H2250Capability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode maximumAudioDelayJitter */
+
+   invokeStartElement (pctxt, "maximumAudioDelayJitter", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumAudioDelayJitter, 0U, 1023U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumAudioDelayJitter);
+
+   invokeEndElement (pctxt, "maximumAudioDelayJitter", -1);
+
+   /* decode receiveMultipointCapability */
+
+   invokeStartElement (pctxt, "receiveMultipointCapability", -1);
+
+   stat = asn1PD_H245MultipointCapability (pctxt, &pvalue->receiveMultipointCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "receiveMultipointCapability", -1);
+
+   /* decode transmitMultipointCapability */
+
+   invokeStartElement (pctxt, "transmitMultipointCapability", -1);
+
+   stat = asn1PD_H245MultipointCapability (pctxt, &pvalue->transmitMultipointCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "transmitMultipointCapability", -1);
+
+   /* decode receiveAndTransmitMultipointCapability */
+
+   invokeStartElement (pctxt, "receiveAndTransmitMultipointCapability", -1);
+
+   stat = asn1PD_H245MultipointCapability (pctxt, &pvalue->receiveAndTransmitMultipointCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "receiveAndTransmitMultipointCapability", -1);
+
+   /* decode mcCapability */
+
+   invokeStartElement (pctxt, "mcCapability", -1);
+
+   stat = asn1PD_H245H2250Capability_mcCapability (pctxt, &pvalue->mcCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mcCapability", -1);
+
+   /* decode rtcpVideoControlCapability */
+
+   invokeStartElement (pctxt, "rtcpVideoControlCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->rtcpVideoControlCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->rtcpVideoControlCapability);
+
+   invokeEndElement (pctxt, "rtcpVideoControlCapability", -1);
+
+   /* decode mediaPacketizationCapability */
+
+   invokeStartElement (pctxt, "mediaPacketizationCapability", -1);
+
+   stat = asn1PD_H245MediaPacketizationCapability (pctxt, &pvalue->mediaPacketizationCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mediaPacketizationCapability", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 4 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.transportCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "transportCapability", -1);
+
+                     stat = asn1PD_H245TransportCapability (pctxt, &pvalue->transportCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "transportCapability", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.redundancyEncodingCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "redundancyEncodingCapability", -1);
+
+                     stat = asn1PD_H245H2250Capability_redundancyEncodingCapability (pctxt, &pvalue->redundancyEncodingCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "redundancyEncodingCapability", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.logicalChannelSwitchingCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "logicalChannelSwitchingCapability", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->logicalChannelSwitchingCapability);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->logicalChannelSwitchingCapability);
+
+                     invokeEndElement (pctxt, "logicalChannelSwitchingCapability", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.t120DynamicPortCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "t120DynamicPortCapability", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->t120DynamicPortCapability);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->t120DynamicPortCapability);
+
+                     invokeEndElement (pctxt, "t120DynamicPortCapability", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexCapability (OOCTXT* pctxt, H245MultiplexCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* h222Capability */
+         case 1:
+            invokeStartElement (pctxt, "h222Capability", -1);
+
+            pvalue->u.h222Capability = ALLOC_ASN1ELEM (pctxt, H245H222Capability);
+
+            stat = asn1PD_H245H222Capability (pctxt, pvalue->u.h222Capability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h222Capability", -1);
+
+            break;
+
+         /* h223Capability */
+         case 2:
+            invokeStartElement (pctxt, "h223Capability", -1);
+
+            pvalue->u.h223Capability = ALLOC_ASN1ELEM (pctxt, H245H223Capability);
+
+            stat = asn1PD_H245H223Capability (pctxt, pvalue->u.h223Capability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h223Capability", -1);
+
+            break;
+
+         /* v76Capability */
+         case 3:
+            invokeStartElement (pctxt, "v76Capability", -1);
+
+            pvalue->u.v76Capability = ALLOC_ASN1ELEM (pctxt, H245V76Capability);
+
+            stat = asn1PD_H245V76Capability (pctxt, pvalue->u.v76Capability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "v76Capability", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* h2250Capability */
+         case 5:
+            invokeStartElement (pctxt, "h2250Capability", -1);
+
+            pvalue->u.h2250Capability = ALLOC_ASN1ELEM (pctxt, H245H2250Capability);
+
+            stat = asn1PD_H245H2250Capability (pctxt, pvalue->u.h2250Capability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h2250Capability", -1);
+
+            break;
+
+         /* genericMultiplexCapability */
+         case 6:
+            invokeStartElement (pctxt, "genericMultiplexCapability", -1);
+
+            pvalue->u.genericMultiplexCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability);
+
+            stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericMultiplexCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericMultiplexCapability", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H261VideoCapability (OOCTXT* pctxt, H245H261VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.qcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cifMPIPresent = optbit;
+
+   /* decode qcifMPI */
+
+   if (pvalue->m.qcifMPIPresent) {
+      invokeStartElement (pctxt, "qcifMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->qcifMPI, 1U, 4U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->qcifMPI);
+
+      invokeEndElement (pctxt, "qcifMPI", -1);
+   }
+
+   /* decode cifMPI */
+
+   if (pvalue->m.cifMPIPresent) {
+      invokeStartElement (pctxt, "cifMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->cifMPI, 1U, 4U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cifMPI);
+
+      invokeEndElement (pctxt, "cifMPI", -1);
+   }
+
+   /* decode temporalSpatialTradeOffCapability */
+
+   invokeStartElement (pctxt, "temporalSpatialTradeOffCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->temporalSpatialTradeOffCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->temporalSpatialTradeOffCapability);
+
+   invokeEndElement (pctxt, "temporalSpatialTradeOffCapability", -1);
+
+   /* decode maxBitRate */
+
+   invokeStartElement (pctxt, "maxBitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maxBitRate, 1U, 19200U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxBitRate);
+
+   invokeEndElement (pctxt, "maxBitRate", -1);
+
+   /* decode stillImageTransmission */
+
+   invokeStartElement (pctxt, "stillImageTransmission", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->stillImageTransmission);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->stillImageTransmission);
+
+   invokeEndElement (pctxt, "stillImageTransmission", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.videoBadMBsCapPresent = 1;
+
+                     invokeStartElement (pctxt, "videoBadMBsCap", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->videoBadMBsCap);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->videoBadMBsCap);
+
+                     invokeEndElement (pctxt, "videoBadMBsCap", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H262VideoCapability (OOCTXT* pctxt, H245H262VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.videoBitRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.vbvBufferSizePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.samplesPerLinePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.linesPerFramePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.framesPerSecondPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.luminanceSampleRatePresent = optbit;
+
+   /* decode profileAndLevel_SPatML */
+
+   invokeStartElement (pctxt, "profileAndLevel_SPatML", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_SPatML);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_SPatML);
+
+   invokeEndElement (pctxt, "profileAndLevel_SPatML", -1);
+
+   /* decode profileAndLevel_MPatLL */
+
+   invokeStartElement (pctxt, "profileAndLevel_MPatLL", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_MPatLL);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_MPatLL);
+
+   invokeEndElement (pctxt, "profileAndLevel_MPatLL", -1);
+
+   /* decode profileAndLevel_MPatML */
+
+   invokeStartElement (pctxt, "profileAndLevel_MPatML", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_MPatML);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_MPatML);
+
+   invokeEndElement (pctxt, "profileAndLevel_MPatML", -1);
+
+   /* decode profileAndLevel_MPatH_14 */
+
+   invokeStartElement (pctxt, "profileAndLevel_MPatH_14", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_MPatH_14);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_MPatH_14);
+
+   invokeEndElement (pctxt, "profileAndLevel_MPatH_14", -1);
+
+   /* decode profileAndLevel_MPatHL */
+
+   invokeStartElement (pctxt, "profileAndLevel_MPatHL", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_MPatHL);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_MPatHL);
+
+   invokeEndElement (pctxt, "profileAndLevel_MPatHL", -1);
+
+   /* decode profileAndLevel_SNRatLL */
+
+   invokeStartElement (pctxt, "profileAndLevel_SNRatLL", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_SNRatLL);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_SNRatLL);
+
+   invokeEndElement (pctxt, "profileAndLevel_SNRatLL", -1);
+
+   /* decode profileAndLevel_SNRatML */
+
+   invokeStartElement (pctxt, "profileAndLevel_SNRatML", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_SNRatML);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_SNRatML);
+
+   invokeEndElement (pctxt, "profileAndLevel_SNRatML", -1);
+
+   /* decode profileAndLevel_SpatialatH_14 */
+
+   invokeStartElement (pctxt, "profileAndLevel_SpatialatH_14", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_SpatialatH_14);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_SpatialatH_14);
+
+   invokeEndElement (pctxt, "profileAndLevel_SpatialatH_14", -1);
+
+   /* decode profileAndLevel_HPatML */
+
+   invokeStartElement (pctxt, "profileAndLevel_HPatML", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_HPatML);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_HPatML);
+
+   invokeEndElement (pctxt, "profileAndLevel_HPatML", -1);
+
+   /* decode profileAndLevel_HPatH_14 */
+
+   invokeStartElement (pctxt, "profileAndLevel_HPatH_14", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_HPatH_14);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_HPatH_14);
+
+   invokeEndElement (pctxt, "profileAndLevel_HPatH_14", -1);
+
+   /* decode profileAndLevel_HPatHL */
+
+   invokeStartElement (pctxt, "profileAndLevel_HPatHL", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_HPatHL);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->profileAndLevel_HPatHL);
+
+   invokeEndElement (pctxt, "profileAndLevel_HPatHL", -1);
+
+   /* decode videoBitRate */
+
+   if (pvalue->m.videoBitRatePresent) {
+      invokeStartElement (pctxt, "videoBitRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->videoBitRate, 0U, 1073741823U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->videoBitRate);
+
+      invokeEndElement (pctxt, "videoBitRate", -1);
+   }
+
+   /* decode vbvBufferSize */
+
+   if (pvalue->m.vbvBufferSizePresent) {
+      invokeStartElement (pctxt, "vbvBufferSize", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->vbvBufferSize, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->vbvBufferSize);
+
+      invokeEndElement (pctxt, "vbvBufferSize", -1);
+   }
+
+   /* decode samplesPerLine */
+
+   if (pvalue->m.samplesPerLinePresent) {
+      invokeStartElement (pctxt, "samplesPerLine", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->samplesPerLine, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->samplesPerLine);
+
+      invokeEndElement (pctxt, "samplesPerLine", -1);
+   }
+
+   /* decode linesPerFrame */
+
+   if (pvalue->m.linesPerFramePresent) {
+      invokeStartElement (pctxt, "linesPerFrame", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->linesPerFrame, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->linesPerFrame);
+
+      invokeEndElement (pctxt, "linesPerFrame", -1);
+   }
+
+   /* decode framesPerSecond */
+
+   if (pvalue->m.framesPerSecondPresent) {
+      invokeStartElement (pctxt, "framesPerSecond", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->framesPerSecond, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->framesPerSecond);
+
+      invokeEndElement (pctxt, "framesPerSecond", -1);
+   }
+
+   /* decode luminanceSampleRate */
+
+   if (pvalue->m.luminanceSampleRatePresent) {
+      invokeStartElement (pctxt, "luminanceSampleRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->luminanceSampleRate);
+
+      invokeEndElement (pctxt, "luminanceSampleRate", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.videoBadMBsCapPresent = 1;
+
+                     invokeStartElement (pctxt, "videoBadMBsCap", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->videoBadMBsCap);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->videoBadMBsCap);
+
+                     invokeEndElement (pctxt, "videoBadMBsCap", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransparencyParameters                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TransparencyParameters (OOCTXT* pctxt, H245TransparencyParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode presentationOrder */
+
+   invokeStartElement (pctxt, "presentationOrder", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->presentationOrder, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->presentationOrder);
+
+   invokeEndElement (pctxt, "presentationOrder", -1);
+
+   /* decode offset_x */
+
+   invokeStartElement (pctxt, "offset_x", -1);
+
+   stat = decodeConsInteger (pctxt, &pvalue->offset_x, -262144, 262143);
+   if (stat != ASN_OK) return stat;
+   invokeIntValue (pctxt, pvalue->offset_x);
+
+   invokeEndElement (pctxt, "offset_x", -1);
+
+   /* decode offset_y */
+
+   invokeStartElement (pctxt, "offset_y", -1);
+
+   stat = decodeConsInteger (pctxt, &pvalue->offset_y, -262144, 262143);
+   if (stat != ASN_OK) return stat;
+   invokeIntValue (pctxt, pvalue->offset_y);
+
+   invokeEndElement (pctxt, "offset_y", -1);
+
+   /* decode scale_x */
+
+   invokeStartElement (pctxt, "scale_x", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->scale_x, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->scale_x);
+
+   invokeEndElement (pctxt, "scale_x", -1);
+
+   /* decode scale_y */
+
+   invokeStartElement (pctxt, "scale_y", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->scale_y, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->scale_y);
+
+   invokeEndElement (pctxt, "scale_y", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_additionalPictureMemory               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RefPictureSelection_additionalPictureMemory (OOCTXT* pctxt, H245RefPictureSelection_additionalPictureMemory* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sqcifAdditionalPictureMemoryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.qcifAdditionalPictureMemoryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cifAdditionalPictureMemoryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cif4AdditionalPictureMemoryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cif16AdditionalPictureMemoryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.bigCpfAdditionalPictureMemoryPresent = optbit;
+
+   /* decode sqcifAdditionalPictureMemory */
+
+   if (pvalue->m.sqcifAdditionalPictureMemoryPresent) {
+      invokeStartElement (pctxt, "sqcifAdditionalPictureMemory", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->sqcifAdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->sqcifAdditionalPictureMemory);
+
+      invokeEndElement (pctxt, "sqcifAdditionalPictureMemory", -1);
+   }
+
+   /* decode qcifAdditionalPictureMemory */
+
+   if (pvalue->m.qcifAdditionalPictureMemoryPresent) {
+      invokeStartElement (pctxt, "qcifAdditionalPictureMemory", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->qcifAdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->qcifAdditionalPictureMemory);
+
+      invokeEndElement (pctxt, "qcifAdditionalPictureMemory", -1);
+   }
+
+   /* decode cifAdditionalPictureMemory */
+
+   if (pvalue->m.cifAdditionalPictureMemoryPresent) {
+      invokeStartElement (pctxt, "cifAdditionalPictureMemory", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->cifAdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cifAdditionalPictureMemory);
+
+      invokeEndElement (pctxt, "cifAdditionalPictureMemory", -1);
+   }
+
+   /* decode cif4AdditionalPictureMemory */
+
+   if (pvalue->m.cif4AdditionalPictureMemoryPresent) {
+      invokeStartElement (pctxt, "cif4AdditionalPictureMemory", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->cif4AdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cif4AdditionalPictureMemory);
+
+      invokeEndElement (pctxt, "cif4AdditionalPictureMemory", -1);
+   }
+
+   /* decode cif16AdditionalPictureMemory */
+
+   if (pvalue->m.cif16AdditionalPictureMemoryPresent) {
+      invokeStartElement (pctxt, "cif16AdditionalPictureMemory", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->cif16AdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cif16AdditionalPictureMemory);
+
+      invokeEndElement (pctxt, "cif16AdditionalPictureMemory", -1);
+   }
+
+   /* decode bigCpfAdditionalPictureMemory */
+
+   if (pvalue->m.bigCpfAdditionalPictureMemoryPresent) {
+      invokeStartElement (pctxt, "bigCpfAdditionalPictureMemory", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->bigCpfAdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->bigCpfAdditionalPictureMemory);
+
+      invokeEndElement (pctxt, "bigCpfAdditionalPictureMemory", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_videoBackChannelSend                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RefPictureSelection_videoBackChannelSend (OOCTXT* pctxt, H245RefPictureSelection_videoBackChannelSend* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* none */
+         case 0:
+            invokeStartElement (pctxt, "none", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "none", -1);
+
+            break;
+
+         /* ackMessageOnly */
+         case 1:
+            invokeStartElement (pctxt, "ackMessageOnly", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "ackMessageOnly", -1);
+
+            break;
+
+         /* nackMessageOnly */
+         case 2:
+            invokeStartElement (pctxt, "nackMessageOnly", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nackMessageOnly", -1);
+
+            break;
+
+         /* ackOrNackMessageOnly */
+         case 3:
+            invokeStartElement (pctxt, "ackOrNackMessageOnly", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "ackOrNackMessageOnly", -1);
+
+            break;
+
+         /* ackAndNackMessage */
+         case 4:
+            invokeStartElement (pctxt, "ackAndNackMessage", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "ackAndNackMessage", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_enhancedReferencePicSelect_subPictur  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode mpuHorizMBs */
+
+   invokeStartElement (pctxt, "mpuHorizMBs", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->mpuHorizMBs, 1U, 128U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->mpuHorizMBs);
+
+   invokeEndElement (pctxt, "mpuHorizMBs", -1);
+
+   /* decode mpuVertMBs */
+
+   invokeStartElement (pctxt, "mpuVertMBs", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->mpuVertMBs, 1U, 72U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->mpuVertMBs);
+
+   invokeEndElement (pctxt, "mpuVertMBs", -1);
+
+   /* decode mpuTotalNumber */
+
+   invokeStartElement (pctxt, "mpuTotalNumber", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->mpuTotalNumber, 1U, 65536U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->mpuTotalNumber);
+
+   invokeEndElement (pctxt, "mpuTotalNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_enhancedReferencePicSelect            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RefPictureSelection_enhancedReferencePicSelect (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.subPictureRemovalParametersPresent = optbit;
+
+   /* decode subPictureRemovalParameters */
+
+   if (pvalue->m.subPictureRemovalParametersPresent) {
+      invokeStartElement (pctxt, "subPictureRemovalParameters", -1);
+
+      stat = asn1PD_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (pctxt, &pvalue->subPictureRemovalParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "subPictureRemovalParameters", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RefPictureSelection (OOCTXT* pctxt, H245RefPictureSelection* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.additionalPictureMemoryPresent = optbit;
+
+   /* decode additionalPictureMemory */
+
+   if (pvalue->m.additionalPictureMemoryPresent) {
+      invokeStartElement (pctxt, "additionalPictureMemory", -1);
+
+      stat = asn1PD_H245RefPictureSelection_additionalPictureMemory (pctxt, &pvalue->additionalPictureMemory);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "additionalPictureMemory", -1);
+   }
+
+   /* decode videoMux */
+
+   invokeStartElement (pctxt, "videoMux", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->videoMux);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->videoMux);
+
+   invokeEndElement (pctxt, "videoMux", -1);
+
+   /* decode videoBackChannelSend */
+
+   invokeStartElement (pctxt, "videoBackChannelSend", -1);
+
+   stat = asn1PD_H245RefPictureSelection_videoBackChannelSend (pctxt, &pvalue->videoBackChannelSend);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "videoBackChannelSend", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.enhancedReferencePicSelectPresent = 1;
+
+                     invokeStartElement (pctxt, "enhancedReferencePicSelect", -1);
+
+                     stat = asn1PD_H245RefPictureSelection_enhancedReferencePicSelect (pctxt, &pvalue->enhancedReferencePicSelect);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "enhancedReferencePicSelect", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureClockFrequency                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureClockFrequency (OOCTXT* pctxt, H245CustomPictureClockFrequency* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sqcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.qcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cif4MPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cif16MPIPresent = optbit;
+
+   /* decode clockConversionCode */
+
+   invokeStartElement (pctxt, "clockConversionCode", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->clockConversionCode, 1000U, 1001U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->clockConversionCode);
+
+   invokeEndElement (pctxt, "clockConversionCode", -1);
+
+   /* decode clockDivisor */
+
+   invokeStartElement (pctxt, "clockDivisor", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->clockDivisor, 1U, 127U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->clockDivisor);
+
+   invokeEndElement (pctxt, "clockDivisor", -1);
+
+   /* decode sqcifMPI */
+
+   if (pvalue->m.sqcifMPIPresent) {
+      invokeStartElement (pctxt, "sqcifMPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->sqcifMPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->sqcifMPI);
+
+      invokeEndElement (pctxt, "sqcifMPI", -1);
+   }
+
+   /* decode qcifMPI */
+
+   if (pvalue->m.qcifMPIPresent) {
+      invokeStartElement (pctxt, "qcifMPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->qcifMPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->qcifMPI);
+
+      invokeEndElement (pctxt, "qcifMPI", -1);
+   }
+
+   /* decode cifMPI */
+
+   if (pvalue->m.cifMPIPresent) {
+      invokeStartElement (pctxt, "cifMPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->cifMPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cifMPI);
+
+      invokeEndElement (pctxt, "cifMPI", -1);
+   }
+
+   /* decode cif4MPI */
+
+   if (pvalue->m.cif4MPIPresent) {
+      invokeStartElement (pctxt, "cif4MPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->cif4MPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cif4MPI);
+
+      invokeEndElement (pctxt, "cif4MPI", -1);
+   }
+
+   /* decode cif16MPI */
+
+   if (pvalue->m.cif16MPIPresent) {
+      invokeStartElement (pctxt, "cif16MPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->cif16MPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cif16MPI);
+
+      invokeEndElement (pctxt, "cif16MPI", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_customPictureClockFrequency                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263Options_customPictureClockFrequency (OOCTXT* pctxt, H245H263Options_customPictureClockFrequency* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   H245CustomPictureClockFrequency* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245CustomPictureClockFrequency);
+
+      stat = asn1PD_H245CustomPictureClockFrequency (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI_customPCF_element                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureFormat_mPI_customPCF_element (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF_element* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode clockConversionCode */
+
+   invokeStartElement (pctxt, "clockConversionCode", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->clockConversionCode, 1000U, 1001U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->clockConversionCode);
+
+   invokeEndElement (pctxt, "clockConversionCode", -1);
+
+   /* decode clockDivisor */
+
+   invokeStartElement (pctxt, "clockDivisor", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->clockDivisor, 1U, 127U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->clockDivisor);
+
+   invokeEndElement (pctxt, "clockDivisor", -1);
+
+   /* decode customMPI */
+
+   invokeStartElement (pctxt, "customMPI", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->customMPI, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->customMPI);
+
+   invokeEndElement (pctxt, "customMPI", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI_customPCF                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureFormat_mPI_customPCF (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   H245CustomPictureFormat_mPI_customPCF_element* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245CustomPictureFormat_mPI_customPCF_element);
+
+      stat = asn1PD_H245CustomPictureFormat_mPI_customPCF_element (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureFormat_mPI (OOCTXT* pctxt, H245CustomPictureFormat_mPI* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.standardMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.customPCFPresent = optbit;
+
+   /* decode standardMPI */
+
+   if (pvalue->m.standardMPIPresent) {
+      invokeStartElement (pctxt, "standardMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->standardMPI, 1U, 31U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->standardMPI);
+
+      invokeEndElement (pctxt, "standardMPI", -1);
+   }
+
+   /* decode customPCF */
+
+   if (pvalue->m.customPCFPresent) {
+      invokeStartElement (pctxt, "customPCF", -1);
+
+      stat = asn1PD_H245CustomPictureFormat_mPI_customPCF (pctxt, &pvalue->customPCF);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "customPCF", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_pixelAspectCo  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->elem[xx1], 1U, 14U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->elem[xx1]);
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_extendedPAR_e  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode width */
+
+   invokeStartElement (pctxt, "width", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->width, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->width);
+
+   invokeEndElement (pctxt, "width", -1);
+
+   /* decode height */
+
+   invokeStartElement (pctxt, "height", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->height, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->height);
+
+   invokeEndElement (pctxt, "height", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_extendedPAR    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element);
+
+      stat = asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* anyPixelAspectRatio */
+         case 0:
+            invokeStartElement (pctxt, "anyPixelAspectRatio", -1);
+
+            stat = DECODEBIT (pctxt, &pvalue->u.anyPixelAspectRatio);
+            if (stat != ASN_OK) return stat;
+            invokeBoolValue (pctxt, pvalue->u.anyPixelAspectRatio);
+
+            invokeEndElement (pctxt, "anyPixelAspectRatio", -1);
+
+            break;
+
+         /* pixelAspectCode */
+         case 1:
+            invokeStartElement (pctxt, "pixelAspectCode", -1);
+
+            pvalue->u.pixelAspectCode = ALLOC_ASN1ELEM (pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode);
+
+            stat = asn1PD_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (pctxt, pvalue->u.pixelAspectCode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "pixelAspectCode", -1);
+
+            break;
+
+         /* extendedPAR */
+         case 2:
+            invokeStartElement (pctxt, "extendedPAR", -1);
+
+            pvalue->u.extendedPAR = ALLOC_ASN1ELEM (pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR);
+
+            stat = asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (pctxt, pvalue->u.extendedPAR);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "extendedPAR", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CustomPictureFormat (OOCTXT* pctxt, H245CustomPictureFormat* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode maxCustomPictureWidth */
+
+   invokeStartElement (pctxt, "maxCustomPictureWidth", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maxCustomPictureWidth, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxCustomPictureWidth);
+
+   invokeEndElement (pctxt, "maxCustomPictureWidth", -1);
+
+   /* decode maxCustomPictureHeight */
+
+   invokeStartElement (pctxt, "maxCustomPictureHeight", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maxCustomPictureHeight, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxCustomPictureHeight);
+
+   invokeEndElement (pctxt, "maxCustomPictureHeight", -1);
+
+   /* decode minCustomPictureWidth */
+
+   invokeStartElement (pctxt, "minCustomPictureWidth", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->minCustomPictureWidth, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->minCustomPictureWidth);
+
+   invokeEndElement (pctxt, "minCustomPictureWidth", -1);
+
+   /* decode minCustomPictureHeight */
+
+   invokeStartElement (pctxt, "minCustomPictureHeight", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->minCustomPictureHeight, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->minCustomPictureHeight);
+
+   invokeEndElement (pctxt, "minCustomPictureHeight", -1);
+
+   /* decode mPI */
+
+   invokeStartElement (pctxt, "mPI", -1);
+
+   stat = asn1PD_H245CustomPictureFormat_mPI (pctxt, &pvalue->mPI);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mPI", -1);
+
+   /* decode pixelAspectInformation */
+
+   invokeStartElement (pctxt, "pixelAspectInformation", -1);
+
+   stat = asn1PD_H245CustomPictureFormat_pixelAspectInformation (pctxt, &pvalue->pixelAspectInformation);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "pixelAspectInformation", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_customPictureFormat                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263Options_customPictureFormat (OOCTXT* pctxt, H245H263Options_customPictureFormat* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   H245CustomPictureFormat* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245CustomPictureFormat);
+
+      stat = asn1PD_H245CustomPictureFormat (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Version3Options                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263Version3Options (OOCTXT* pctxt, H245H263Version3Options* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode dataPartitionedSlices */
+
+   invokeStartElement (pctxt, "dataPartitionedSlices", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dataPartitionedSlices);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dataPartitionedSlices);
+
+   invokeEndElement (pctxt, "dataPartitionedSlices", -1);
+
+   /* decode fixedPointIDCT0 */
+
+   invokeStartElement (pctxt, "fixedPointIDCT0", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fixedPointIDCT0);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fixedPointIDCT0);
+
+   invokeEndElement (pctxt, "fixedPointIDCT0", -1);
+
+   /* decode interlacedFields */
+
+   invokeStartElement (pctxt, "interlacedFields", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->interlacedFields);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->interlacedFields);
+
+   invokeEndElement (pctxt, "interlacedFields", -1);
+
+   /* decode currentPictureHeaderRepetition */
+
+   invokeStartElement (pctxt, "currentPictureHeaderRepetition", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->currentPictureHeaderRepetition);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->currentPictureHeaderRepetition);
+
+   invokeEndElement (pctxt, "currentPictureHeaderRepetition", -1);
+
+   /* decode previousPictureHeaderRepetition */
+
+   invokeStartElement (pctxt, "previousPictureHeaderRepetition", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->previousPictureHeaderRepetition);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->previousPictureHeaderRepetition);
+
+   invokeEndElement (pctxt, "previousPictureHeaderRepetition", -1);
+
+   /* decode nextPictureHeaderRepetition */
+
+   invokeStartElement (pctxt, "nextPictureHeaderRepetition", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->nextPictureHeaderRepetition);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->nextPictureHeaderRepetition);
+
+   invokeEndElement (pctxt, "nextPictureHeaderRepetition", -1);
+
+   /* decode pictureNumber */
+
+   invokeStartElement (pctxt, "pictureNumber", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->pictureNumber);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->pictureNumber);
+
+   invokeEndElement (pctxt, "pictureNumber", -1);
+
+   /* decode spareReferencePictures */
+
+   invokeStartElement (pctxt, "spareReferencePictures", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->spareReferencePictures);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->spareReferencePictures);
+
+   invokeEndElement (pctxt, "spareReferencePictures", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263ModeComboFlags                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263ModeComboFlags (OOCTXT* pctxt, H245H263ModeComboFlags* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode unrestrictedVector */
+
+   invokeStartElement (pctxt, "unrestrictedVector", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->unrestrictedVector);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->unrestrictedVector);
+
+   invokeEndElement (pctxt, "unrestrictedVector", -1);
+
+   /* decode arithmeticCoding */
+
+   invokeStartElement (pctxt, "arithmeticCoding", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->arithmeticCoding);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->arithmeticCoding);
+
+   invokeEndElement (pctxt, "arithmeticCoding", -1);
+
+   /* decode advancedPrediction */
+
+   invokeStartElement (pctxt, "advancedPrediction", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->advancedPrediction);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->advancedPrediction);
+
+   invokeEndElement (pctxt, "advancedPrediction", -1);
+
+   /* decode pbFrames */
+
+   invokeStartElement (pctxt, "pbFrames", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->pbFrames);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->pbFrames);
+
+   invokeEndElement (pctxt, "pbFrames", -1);
+
+   /* decode advancedIntraCodingMode */
+
+   invokeStartElement (pctxt, "advancedIntraCodingMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->advancedIntraCodingMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->advancedIntraCodingMode);
+
+   invokeEndElement (pctxt, "advancedIntraCodingMode", -1);
+
+   /* decode deblockingFilterMode */
+
+   invokeStartElement (pctxt, "deblockingFilterMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->deblockingFilterMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->deblockingFilterMode);
+
+   invokeEndElement (pctxt, "deblockingFilterMode", -1);
+
+   /* decode unlimitedMotionVectors */
+
+   invokeStartElement (pctxt, "unlimitedMotionVectors", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->unlimitedMotionVectors);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->unlimitedMotionVectors);
+
+   invokeEndElement (pctxt, "unlimitedMotionVectors", -1);
+
+   /* decode slicesInOrder_NonRect */
+
+   invokeStartElement (pctxt, "slicesInOrder_NonRect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->slicesInOrder_NonRect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->slicesInOrder_NonRect);
+
+   invokeEndElement (pctxt, "slicesInOrder_NonRect", -1);
+
+   /* decode slicesInOrder_Rect */
+
+   invokeStartElement (pctxt, "slicesInOrder_Rect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->slicesInOrder_Rect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->slicesInOrder_Rect);
+
+   invokeEndElement (pctxt, "slicesInOrder_Rect", -1);
+
+   /* decode slicesNoOrder_NonRect */
+
+   invokeStartElement (pctxt, "slicesNoOrder_NonRect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->slicesNoOrder_NonRect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->slicesNoOrder_NonRect);
+
+   invokeEndElement (pctxt, "slicesNoOrder_NonRect", -1);
+
+   /* decode slicesNoOrder_Rect */
+
+   invokeStartElement (pctxt, "slicesNoOrder_Rect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->slicesNoOrder_Rect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->slicesNoOrder_Rect);
+
+   invokeEndElement (pctxt, "slicesNoOrder_Rect", -1);
+
+   /* decode improvedPBFramesMode */
+
+   invokeStartElement (pctxt, "improvedPBFramesMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->improvedPBFramesMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->improvedPBFramesMode);
+
+   invokeEndElement (pctxt, "improvedPBFramesMode", -1);
+
+   /* decode referencePicSelect */
+
+   invokeStartElement (pctxt, "referencePicSelect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->referencePicSelect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->referencePicSelect);
+
+   invokeEndElement (pctxt, "referencePicSelect", -1);
+
+   /* decode dynamicPictureResizingByFour */
+
+   invokeStartElement (pctxt, "dynamicPictureResizingByFour", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dynamicPictureResizingByFour);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dynamicPictureResizingByFour);
+
+   invokeEndElement (pctxt, "dynamicPictureResizingByFour", -1);
+
+   /* decode dynamicPictureResizingSixteenthPel */
+
+   invokeStartElement (pctxt, "dynamicPictureResizingSixteenthPel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dynamicPictureResizingSixteenthPel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dynamicPictureResizingSixteenthPel);
+
+   invokeEndElement (pctxt, "dynamicPictureResizingSixteenthPel", -1);
+
+   /* decode dynamicWarpingHalfPel */
+
+   invokeStartElement (pctxt, "dynamicWarpingHalfPel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dynamicWarpingHalfPel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dynamicWarpingHalfPel);
+
+   invokeEndElement (pctxt, "dynamicWarpingHalfPel", -1);
+
+   /* decode dynamicWarpingSixteenthPel */
+
+   invokeStartElement (pctxt, "dynamicWarpingSixteenthPel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dynamicWarpingSixteenthPel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dynamicWarpingSixteenthPel);
+
+   invokeEndElement (pctxt, "dynamicWarpingSixteenthPel", -1);
+
+   /* decode reducedResolutionUpdate */
+
+   invokeStartElement (pctxt, "reducedResolutionUpdate", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->reducedResolutionUpdate);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->reducedResolutionUpdate);
+
+   invokeEndElement (pctxt, "reducedResolutionUpdate", -1);
+
+   /* decode independentSegmentDecoding */
+
+   invokeStartElement (pctxt, "independentSegmentDecoding", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->independentSegmentDecoding);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->independentSegmentDecoding);
+
+   invokeEndElement (pctxt, "independentSegmentDecoding", -1);
+
+   /* decode alternateInterVLCMode */
+
+   invokeStartElement (pctxt, "alternateInterVLCMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->alternateInterVLCMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->alternateInterVLCMode);
+
+   invokeEndElement (pctxt, "alternateInterVLCMode", -1);
+
+   /* decode modifiedQuantizationMode */
+
+   invokeStartElement (pctxt, "modifiedQuantizationMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->modifiedQuantizationMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->modifiedQuantizationMode);
+
+   invokeEndElement (pctxt, "modifiedQuantizationMode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.enhancedReferencePicSelectPresent = 1;
+
+                     invokeStartElement (pctxt, "enhancedReferencePicSelect", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->enhancedReferencePicSelect);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->enhancedReferencePicSelect);
+
+                     invokeEndElement (pctxt, "enhancedReferencePicSelect", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.h263Version3OptionsPresent = 1;
+
+                     invokeStartElement (pctxt, "h263Version3Options", -1);
+
+                     stat = asn1PD_H245H263Version3Options (pctxt, &pvalue->h263Version3Options);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h263Version3Options", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoModeCombos_h263VideoCoupledModes                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263VideoModeCombos_h263VideoCoupledModes (OOCTXT* pctxt, H245H263VideoModeCombos_h263VideoCoupledModes* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   H245H263ModeComboFlags* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245H263ModeComboFlags);
+
+      stat = asn1PD_H245H263ModeComboFlags (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoModeCombos                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263VideoModeCombos (OOCTXT* pctxt, H245H263VideoModeCombos* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode h263VideoUncoupledModes */
+
+   invokeStartElement (pctxt, "h263VideoUncoupledModes", -1);
+
+   stat = asn1PD_H245H263ModeComboFlags (pctxt, &pvalue->h263VideoUncoupledModes);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "h263VideoUncoupledModes", -1);
+
+   /* decode h263VideoCoupledModes */
+
+   invokeStartElement (pctxt, "h263VideoCoupledModes", -1);
+
+   stat = asn1PD_H245H263VideoModeCombos_h263VideoCoupledModes (pctxt, &pvalue->h263VideoCoupledModes);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "h263VideoCoupledModes", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_modeCombos                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263Options_modeCombos (OOCTXT* pctxt, H245H263Options_modeCombos* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   H245H263VideoModeCombos* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245H263VideoModeCombos);
+
+      stat = asn1PD_H245H263VideoModeCombos (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263Options (OOCTXT* pctxt, H245H263Options* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.transparencyParametersPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.refPictureSelectionPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.customPictureClockFrequencyPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.customPictureFormatPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.modeCombosPresent = optbit;
+
+   /* decode advancedIntraCodingMode */
+
+   invokeStartElement (pctxt, "advancedIntraCodingMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->advancedIntraCodingMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->advancedIntraCodingMode);
+
+   invokeEndElement (pctxt, "advancedIntraCodingMode", -1);
+
+   /* decode deblockingFilterMode */
+
+   invokeStartElement (pctxt, "deblockingFilterMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->deblockingFilterMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->deblockingFilterMode);
+
+   invokeEndElement (pctxt, "deblockingFilterMode", -1);
+
+   /* decode improvedPBFramesMode */
+
+   invokeStartElement (pctxt, "improvedPBFramesMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->improvedPBFramesMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->improvedPBFramesMode);
+
+   invokeEndElement (pctxt, "improvedPBFramesMode", -1);
+
+   /* decode unlimitedMotionVectors */
+
+   invokeStartElement (pctxt, "unlimitedMotionVectors", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->unlimitedMotionVectors);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->unlimitedMotionVectors);
+
+   invokeEndElement (pctxt, "unlimitedMotionVectors", -1);
+
+   /* decode fullPictureFreeze */
+
+   invokeStartElement (pctxt, "fullPictureFreeze", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fullPictureFreeze);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fullPictureFreeze);
+
+   invokeEndElement (pctxt, "fullPictureFreeze", -1);
+
+   /* decode partialPictureFreezeAndRelease */
+
+   invokeStartElement (pctxt, "partialPictureFreezeAndRelease", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->partialPictureFreezeAndRelease);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->partialPictureFreezeAndRelease);
+
+   invokeEndElement (pctxt, "partialPictureFreezeAndRelease", -1);
+
+   /* decode resizingPartPicFreezeAndRelease */
+
+   invokeStartElement (pctxt, "resizingPartPicFreezeAndRelease", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->resizingPartPicFreezeAndRelease);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->resizingPartPicFreezeAndRelease);
+
+   invokeEndElement (pctxt, "resizingPartPicFreezeAndRelease", -1);
+
+   /* decode fullPictureSnapshot */
+
+   invokeStartElement (pctxt, "fullPictureSnapshot", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fullPictureSnapshot);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fullPictureSnapshot);
+
+   invokeEndElement (pctxt, "fullPictureSnapshot", -1);
+
+   /* decode partialPictureSnapshot */
+
+   invokeStartElement (pctxt, "partialPictureSnapshot", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->partialPictureSnapshot);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->partialPictureSnapshot);
+
+   invokeEndElement (pctxt, "partialPictureSnapshot", -1);
+
+   /* decode videoSegmentTagging */
+
+   invokeStartElement (pctxt, "videoSegmentTagging", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->videoSegmentTagging);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->videoSegmentTagging);
+
+   invokeEndElement (pctxt, "videoSegmentTagging", -1);
+
+   /* decode progressiveRefinement */
+
+   invokeStartElement (pctxt, "progressiveRefinement", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->progressiveRefinement);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->progressiveRefinement);
+
+   invokeEndElement (pctxt, "progressiveRefinement", -1);
+
+   /* decode dynamicPictureResizingByFour */
+
+   invokeStartElement (pctxt, "dynamicPictureResizingByFour", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dynamicPictureResizingByFour);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dynamicPictureResizingByFour);
+
+   invokeEndElement (pctxt, "dynamicPictureResizingByFour", -1);
+
+   /* decode dynamicPictureResizingSixteenthPel */
+
+   invokeStartElement (pctxt, "dynamicPictureResizingSixteenthPel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dynamicPictureResizingSixteenthPel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dynamicPictureResizingSixteenthPel);
+
+   invokeEndElement (pctxt, "dynamicPictureResizingSixteenthPel", -1);
+
+   /* decode dynamicWarpingHalfPel */
+
+   invokeStartElement (pctxt, "dynamicWarpingHalfPel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dynamicWarpingHalfPel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dynamicWarpingHalfPel);
+
+   invokeEndElement (pctxt, "dynamicWarpingHalfPel", -1);
+
+   /* decode dynamicWarpingSixteenthPel */
+
+   invokeStartElement (pctxt, "dynamicWarpingSixteenthPel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->dynamicWarpingSixteenthPel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->dynamicWarpingSixteenthPel);
+
+   invokeEndElement (pctxt, "dynamicWarpingSixteenthPel", -1);
+
+   /* decode independentSegmentDecoding */
+
+   invokeStartElement (pctxt, "independentSegmentDecoding", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->independentSegmentDecoding);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->independentSegmentDecoding);
+
+   invokeEndElement (pctxt, "independentSegmentDecoding", -1);
+
+   /* decode slicesInOrder_NonRect */
+
+   invokeStartElement (pctxt, "slicesInOrder_NonRect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->slicesInOrder_NonRect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->slicesInOrder_NonRect);
+
+   invokeEndElement (pctxt, "slicesInOrder_NonRect", -1);
+
+   /* decode slicesInOrder_Rect */
+
+   invokeStartElement (pctxt, "slicesInOrder_Rect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->slicesInOrder_Rect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->slicesInOrder_Rect);
+
+   invokeEndElement (pctxt, "slicesInOrder_Rect", -1);
+
+   /* decode slicesNoOrder_NonRect */
+
+   invokeStartElement (pctxt, "slicesNoOrder_NonRect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->slicesNoOrder_NonRect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->slicesNoOrder_NonRect);
+
+   invokeEndElement (pctxt, "slicesNoOrder_NonRect", -1);
+
+   /* decode slicesNoOrder_Rect */
+
+   invokeStartElement (pctxt, "slicesNoOrder_Rect", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->slicesNoOrder_Rect);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->slicesNoOrder_Rect);
+
+   invokeEndElement (pctxt, "slicesNoOrder_Rect", -1);
+
+   /* decode alternateInterVLCMode */
+
+   invokeStartElement (pctxt, "alternateInterVLCMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->alternateInterVLCMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->alternateInterVLCMode);
+
+   invokeEndElement (pctxt, "alternateInterVLCMode", -1);
+
+   /* decode modifiedQuantizationMode */
+
+   invokeStartElement (pctxt, "modifiedQuantizationMode", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->modifiedQuantizationMode);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->modifiedQuantizationMode);
+
+   invokeEndElement (pctxt, "modifiedQuantizationMode", -1);
+
+   /* decode reducedResolutionUpdate */
+
+   invokeStartElement (pctxt, "reducedResolutionUpdate", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->reducedResolutionUpdate);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->reducedResolutionUpdate);
+
+   invokeEndElement (pctxt, "reducedResolutionUpdate", -1);
+
+   /* decode transparencyParameters */
+
+   if (pvalue->m.transparencyParametersPresent) {
+      invokeStartElement (pctxt, "transparencyParameters", -1);
+
+      stat = asn1PD_H245TransparencyParameters (pctxt, &pvalue->transparencyParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "transparencyParameters", -1);
+   }
+
+   /* decode separateVideoBackChannel */
+
+   invokeStartElement (pctxt, "separateVideoBackChannel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->separateVideoBackChannel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->separateVideoBackChannel);
+
+   invokeEndElement (pctxt, "separateVideoBackChannel", -1);
+
+   /* decode refPictureSelection */
+
+   if (pvalue->m.refPictureSelectionPresent) {
+      invokeStartElement (pctxt, "refPictureSelection", -1);
+
+      stat = asn1PD_H245RefPictureSelection (pctxt, &pvalue->refPictureSelection);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "refPictureSelection", -1);
+   }
+
+   /* decode customPictureClockFrequency */
+
+   if (pvalue->m.customPictureClockFrequencyPresent) {
+      invokeStartElement (pctxt, "customPictureClockFrequency", -1);
+
+      stat = asn1PD_H245H263Options_customPictureClockFrequency (pctxt, &pvalue->customPictureClockFrequency);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "customPictureClockFrequency", -1);
+   }
+
+   /* decode customPictureFormat */
+
+   if (pvalue->m.customPictureFormatPresent) {
+      invokeStartElement (pctxt, "customPictureFormat", -1);
+
+      stat = asn1PD_H245H263Options_customPictureFormat (pctxt, &pvalue->customPictureFormat);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "customPictureFormat", -1);
+   }
+
+   /* decode modeCombos */
+
+   if (pvalue->m.modeCombosPresent) {
+      invokeStartElement (pctxt, "modeCombos", -1);
+
+      stat = asn1PD_H245H263Options_modeCombos (pctxt, &pvalue->modeCombos);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "modeCombos", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.videoBadMBsCapPresent = 1;
+
+                     invokeStartElement (pctxt, "videoBadMBsCap", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->videoBadMBsCap);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->videoBadMBsCap);
+
+                     invokeEndElement (pctxt, "videoBadMBsCap", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.h263Version3OptionsPresent = 1;
+
+                     invokeStartElement (pctxt, "h263Version3Options", -1);
+
+                     stat = asn1PD_H245H263Version3Options (pctxt, &pvalue->h263Version3Options);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h263Version3Options", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementOptions                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EnhancementOptions (OOCTXT* pctxt, H245EnhancementOptions* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sqcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.qcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cif4MPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cif16MPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.slowSqcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.slowQcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.slowCifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.slowCif4MPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.slowCif16MPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h263OptionsPresent = optbit;
+
+   /* decode sqcifMPI */
+
+   if (pvalue->m.sqcifMPIPresent) {
+      invokeStartElement (pctxt, "sqcifMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->sqcifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->sqcifMPI);
+
+      invokeEndElement (pctxt, "sqcifMPI", -1);
+   }
+
+   /* decode qcifMPI */
+
+   if (pvalue->m.qcifMPIPresent) {
+      invokeStartElement (pctxt, "qcifMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->qcifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->qcifMPI);
+
+      invokeEndElement (pctxt, "qcifMPI", -1);
+   }
+
+   /* decode cifMPI */
+
+   if (pvalue->m.cifMPIPresent) {
+      invokeStartElement (pctxt, "cifMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->cifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cifMPI);
+
+      invokeEndElement (pctxt, "cifMPI", -1);
+   }
+
+   /* decode cif4MPI */
+
+   if (pvalue->m.cif4MPIPresent) {
+      invokeStartElement (pctxt, "cif4MPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->cif4MPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cif4MPI);
+
+      invokeEndElement (pctxt, "cif4MPI", -1);
+   }
+
+   /* decode cif16MPI */
+
+   if (pvalue->m.cif16MPIPresent) {
+      invokeStartElement (pctxt, "cif16MPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->cif16MPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cif16MPI);
+
+      invokeEndElement (pctxt, "cif16MPI", -1);
+   }
+
+   /* decode maxBitRate */
+
+   invokeStartElement (pctxt, "maxBitRate", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->maxBitRate, 1U, 192400U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxBitRate);
+
+   invokeEndElement (pctxt, "maxBitRate", -1);
+
+   /* decode unrestrictedVector */
+
+   invokeStartElement (pctxt, "unrestrictedVector", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->unrestrictedVector);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->unrestrictedVector);
+
+   invokeEndElement (pctxt, "unrestrictedVector", -1);
+
+   /* decode arithmeticCoding */
+
+   invokeStartElement (pctxt, "arithmeticCoding", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->arithmeticCoding);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->arithmeticCoding);
+
+   invokeEndElement (pctxt, "arithmeticCoding", -1);
+
+   /* decode temporalSpatialTradeOffCapability */
+
+   invokeStartElement (pctxt, "temporalSpatialTradeOffCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->temporalSpatialTradeOffCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->temporalSpatialTradeOffCapability);
+
+   invokeEndElement (pctxt, "temporalSpatialTradeOffCapability", -1);
+
+   /* decode slowSqcifMPI */
+
+   if (pvalue->m.slowSqcifMPIPresent) {
+      invokeStartElement (pctxt, "slowSqcifMPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->slowSqcifMPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->slowSqcifMPI);
+
+      invokeEndElement (pctxt, "slowSqcifMPI", -1);
+   }
+
+   /* decode slowQcifMPI */
+
+   if (pvalue->m.slowQcifMPIPresent) {
+      invokeStartElement (pctxt, "slowQcifMPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->slowQcifMPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->slowQcifMPI);
+
+      invokeEndElement (pctxt, "slowQcifMPI", -1);
+   }
+
+   /* decode slowCifMPI */
+
+   if (pvalue->m.slowCifMPIPresent) {
+      invokeStartElement (pctxt, "slowCifMPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->slowCifMPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->slowCifMPI);
+
+      invokeEndElement (pctxt, "slowCifMPI", -1);
+   }
+
+   /* decode slowCif4MPI */
+
+   if (pvalue->m.slowCif4MPIPresent) {
+      invokeStartElement (pctxt, "slowCif4MPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->slowCif4MPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->slowCif4MPI);
+
+      invokeEndElement (pctxt, "slowCif4MPI", -1);
+   }
+
+   /* decode slowCif16MPI */
+
+   if (pvalue->m.slowCif16MPIPresent) {
+      invokeStartElement (pctxt, "slowCif16MPI", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->slowCif16MPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->slowCif16MPI);
+
+      invokeEndElement (pctxt, "slowCif16MPI", -1);
+   }
+
+   /* decode errorCompensation */
+
+   invokeStartElement (pctxt, "errorCompensation", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->errorCompensation);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->errorCompensation);
+
+   invokeEndElement (pctxt, "errorCompensation", -1);
+
+   /* decode h263Options */
+
+   if (pvalue->m.h263OptionsPresent) {
+      invokeStartElement (pctxt, "h263Options", -1);
+
+      stat = asn1PD_H245H263Options (pctxt, &pvalue->h263Options);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h263Options", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_snrEnhancement                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EnhancementLayerInfo_snrEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_snrEnhancement* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 };
+   int stat = ASN_OK;
+   H245EnhancementOptions* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245EnhancementOptions);
+
+      stat = asn1PD_H245EnhancementOptions (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_spatialEnhancement                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EnhancementLayerInfo_spatialEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_spatialEnhancement* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 };
+   int stat = ASN_OK;
+   H245EnhancementOptions* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245EnhancementOptions);
+
+      stat = asn1PD_H245EnhancementOptions (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BEnhancementParameters                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245BEnhancementParameters (OOCTXT* pctxt, H245BEnhancementParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode enhancementOptions */
+
+   invokeStartElement (pctxt, "enhancementOptions", -1);
+
+   stat = asn1PD_H245EnhancementOptions (pctxt, &pvalue->enhancementOptions);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "enhancementOptions", -1);
+
+   /* decode numberOfBPictures */
+
+   invokeStartElement (pctxt, "numberOfBPictures", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->numberOfBPictures, 1U, 64U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfBPictures);
+
+   invokeEndElement (pctxt, "numberOfBPictures", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_bPictureEnhancement                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EnhancementLayerInfo_bPictureEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_bPictureEnhancement* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 };
+   int stat = ASN_OK;
+   H245BEnhancementParameters* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245BEnhancementParameters);
+
+      stat = asn1PD_H245BEnhancementParameters (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EnhancementLayerInfo (OOCTXT* pctxt, H245EnhancementLayerInfo* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.snrEnhancementPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.spatialEnhancementPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.bPictureEnhancementPresent = optbit;
+
+   /* decode baseBitRateConstrained */
+
+   invokeStartElement (pctxt, "baseBitRateConstrained", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->baseBitRateConstrained);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->baseBitRateConstrained);
+
+   invokeEndElement (pctxt, "baseBitRateConstrained", -1);
+
+   /* decode snrEnhancement */
+
+   if (pvalue->m.snrEnhancementPresent) {
+      invokeStartElement (pctxt, "snrEnhancement", -1);
+
+      stat = asn1PD_H245EnhancementLayerInfo_snrEnhancement (pctxt, &pvalue->snrEnhancement);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "snrEnhancement", -1);
+   }
+
+   /* decode spatialEnhancement */
+
+   if (pvalue->m.spatialEnhancementPresent) {
+      invokeStartElement (pctxt, "spatialEnhancement", -1);
+
+      stat = asn1PD_H245EnhancementLayerInfo_spatialEnhancement (pctxt, &pvalue->spatialEnhancement);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "spatialEnhancement", -1);
+   }
+
+   /* decode bPictureEnhancement */
+
+   if (pvalue->m.bPictureEnhancementPresent) {
+      invokeStartElement (pctxt, "bPictureEnhancement", -1);
+
+      stat = asn1PD_H245EnhancementLayerInfo_bPictureEnhancement (pctxt, &pvalue->bPictureEnhancement);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "bPictureEnhancement", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263VideoCapability (OOCTXT* pctxt, H245H263VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sqcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.qcifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cifMPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cif4MPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.cif16MPIPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.hrd_BPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.bppMaxKbPresent = optbit;
+
+   /* decode sqcifMPI */
+
+   if (pvalue->m.sqcifMPIPresent) {
+      invokeStartElement (pctxt, "sqcifMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->sqcifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->sqcifMPI);
+
+      invokeEndElement (pctxt, "sqcifMPI", -1);
+   }
+
+   /* decode qcifMPI */
+
+   if (pvalue->m.qcifMPIPresent) {
+      invokeStartElement (pctxt, "qcifMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->qcifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->qcifMPI);
+
+      invokeEndElement (pctxt, "qcifMPI", -1);
+   }
+
+   /* decode cifMPI */
+
+   if (pvalue->m.cifMPIPresent) {
+      invokeStartElement (pctxt, "cifMPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->cifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cifMPI);
+
+      invokeEndElement (pctxt, "cifMPI", -1);
+   }
+
+   /* decode cif4MPI */
+
+   if (pvalue->m.cif4MPIPresent) {
+      invokeStartElement (pctxt, "cif4MPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->cif4MPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cif4MPI);
+
+      invokeEndElement (pctxt, "cif4MPI", -1);
+   }
+
+   /* decode cif16MPI */
+
+   if (pvalue->m.cif16MPIPresent) {
+      invokeStartElement (pctxt, "cif16MPI", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->cif16MPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->cif16MPI);
+
+      invokeEndElement (pctxt, "cif16MPI", -1);
+   }
+
+   /* decode maxBitRate */
+
+   invokeStartElement (pctxt, "maxBitRate", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->maxBitRate, 1U, 192400U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxBitRate);
+
+   invokeEndElement (pctxt, "maxBitRate", -1);
+
+   /* decode unrestrictedVector */
+
+   invokeStartElement (pctxt, "unrestrictedVector", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->unrestrictedVector);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->unrestrictedVector);
+
+   invokeEndElement (pctxt, "unrestrictedVector", -1);
+
+   /* decode arithmeticCoding */
+
+   invokeStartElement (pctxt, "arithmeticCoding", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->arithmeticCoding);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->arithmeticCoding);
+
+   invokeEndElement (pctxt, "arithmeticCoding", -1);
+
+   /* decode advancedPrediction */
+
+   invokeStartElement (pctxt, "advancedPrediction", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->advancedPrediction);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->advancedPrediction);
+
+   invokeEndElement (pctxt, "advancedPrediction", -1);
+
+   /* decode pbFrames */
+
+   invokeStartElement (pctxt, "pbFrames", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->pbFrames);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->pbFrames);
+
+   invokeEndElement (pctxt, "pbFrames", -1);
+
+   /* decode temporalSpatialTradeOffCapability */
+
+   invokeStartElement (pctxt, "temporalSpatialTradeOffCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->temporalSpatialTradeOffCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->temporalSpatialTradeOffCapability);
+
+   invokeEndElement (pctxt, "temporalSpatialTradeOffCapability", -1);
+
+   /* decode hrd_B */
+
+   if (pvalue->m.hrd_BPresent) {
+      invokeStartElement (pctxt, "hrd_B", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->hrd_B, 0U, 524287U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->hrd_B);
+
+      invokeEndElement (pctxt, "hrd_B", -1);
+   }
+
+   /* decode bppMaxKb */
+
+   if (pvalue->m.bppMaxKbPresent) {
+      invokeStartElement (pctxt, "bppMaxKb", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->bppMaxKb, 0U, 65535U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->bppMaxKb);
+
+      invokeEndElement (pctxt, "bppMaxKb", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 8 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.slowSqcifMPIPresent = 1;
+
+                     invokeStartElement (pctxt, "slowSqcifMPI", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->slowSqcifMPI, 1U, 3600U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->slowSqcifMPI);
+
+                     invokeEndElement (pctxt, "slowSqcifMPI", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.slowQcifMPIPresent = 1;
+
+                     invokeStartElement (pctxt, "slowQcifMPI", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->slowQcifMPI, 1U, 3600U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->slowQcifMPI);
+
+                     invokeEndElement (pctxt, "slowQcifMPI", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.slowCifMPIPresent = 1;
+
+                     invokeStartElement (pctxt, "slowCifMPI", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->slowCifMPI, 1U, 3600U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->slowCifMPI);
+
+                     invokeEndElement (pctxt, "slowCifMPI", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.slowCif4MPIPresent = 1;
+
+                     invokeStartElement (pctxt, "slowCif4MPI", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->slowCif4MPI, 1U, 3600U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->slowCif4MPI);
+
+                     invokeEndElement (pctxt, "slowCif4MPI", -1);
+                     break;
+
+                  case 4:
+                     pvalue->m.slowCif16MPIPresent = 1;
+
+                     invokeStartElement (pctxt, "slowCif16MPI", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->slowCif16MPI, 1U, 3600U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->slowCif16MPI);
+
+                     invokeEndElement (pctxt, "slowCif16MPI", -1);
+                     break;
+
+                  case 5:
+                     pvalue->m.errorCompensationPresent = 1;
+
+                     invokeStartElement (pctxt, "errorCompensation", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->errorCompensation);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->errorCompensation);
+
+                     invokeEndElement (pctxt, "errorCompensation", -1);
+                     break;
+
+                  case 6:
+                     pvalue->m.enhancementLayerInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "enhancementLayerInfo", -1);
+
+                     stat = asn1PD_H245EnhancementLayerInfo (pctxt, &pvalue->enhancementLayerInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "enhancementLayerInfo", -1);
+                     break;
+
+                  case 7:
+                     pvalue->m.h263OptionsPresent = 1;
+
+                     invokeStartElement (pctxt, "h263Options", -1);
+
+                     stat = asn1PD_H245H263Options (pctxt, &pvalue->h263Options);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h263Options", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172VideoCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS11172VideoCapability (OOCTXT* pctxt, H245IS11172VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.videoBitRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.vbvBufferSizePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.samplesPerLinePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.linesPerFramePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.pictureRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.luminanceSampleRatePresent = optbit;
+
+   /* decode constrainedBitstream */
+
+   invokeStartElement (pctxt, "constrainedBitstream", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->constrainedBitstream);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->constrainedBitstream);
+
+   invokeEndElement (pctxt, "constrainedBitstream", -1);
+
+   /* decode videoBitRate */
+
+   if (pvalue->m.videoBitRatePresent) {
+      invokeStartElement (pctxt, "videoBitRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->videoBitRate, 0U, 1073741823U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->videoBitRate);
+
+      invokeEndElement (pctxt, "videoBitRate", -1);
+   }
+
+   /* decode vbvBufferSize */
+
+   if (pvalue->m.vbvBufferSizePresent) {
+      invokeStartElement (pctxt, "vbvBufferSize", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->vbvBufferSize, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->vbvBufferSize);
+
+      invokeEndElement (pctxt, "vbvBufferSize", -1);
+   }
+
+   /* decode samplesPerLine */
+
+   if (pvalue->m.samplesPerLinePresent) {
+      invokeStartElement (pctxt, "samplesPerLine", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->samplesPerLine, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->samplesPerLine);
+
+      invokeEndElement (pctxt, "samplesPerLine", -1);
+   }
+
+   /* decode linesPerFrame */
+
+   if (pvalue->m.linesPerFramePresent) {
+      invokeStartElement (pctxt, "linesPerFrame", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->linesPerFrame, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->linesPerFrame);
+
+      invokeEndElement (pctxt, "linesPerFrame", -1);
+   }
+
+   /* decode pictureRate */
+
+   if (pvalue->m.pictureRatePresent) {
+      invokeStartElement (pctxt, "pictureRate", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->pictureRate, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->pictureRate);
+
+      invokeEndElement (pctxt, "pictureRate", -1);
+   }
+
+   /* decode luminanceSampleRate */
+
+   if (pvalue->m.luminanceSampleRatePresent) {
+      invokeStartElement (pctxt, "luminanceSampleRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->luminanceSampleRate);
+
+      invokeEndElement (pctxt, "luminanceSampleRate", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.videoBadMBsCapPresent = 1;
+
+                     invokeStartElement (pctxt, "videoBadMBsCap", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->videoBadMBsCap);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->videoBadMBsCap);
+
+                     invokeEndElement (pctxt, "videoBadMBsCap", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VideoCapability                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VideoCapability (OOCTXT* pctxt, H245VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* h261VideoCapability */
+         case 1:
+            invokeStartElement (pctxt, "h261VideoCapability", -1);
+
+            pvalue->u.h261VideoCapability = ALLOC_ASN1ELEM (pctxt, H245H261VideoCapability);
+
+            stat = asn1PD_H245H261VideoCapability (pctxt, pvalue->u.h261VideoCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h261VideoCapability", -1);
+
+            break;
+
+         /* h262VideoCapability */
+         case 2:
+            invokeStartElement (pctxt, "h262VideoCapability", -1);
+
+            pvalue->u.h262VideoCapability = ALLOC_ASN1ELEM (pctxt, H245H262VideoCapability);
+
+            stat = asn1PD_H245H262VideoCapability (pctxt, pvalue->u.h262VideoCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h262VideoCapability", -1);
+
+            break;
+
+         /* h263VideoCapability */
+         case 3:
+            invokeStartElement (pctxt, "h263VideoCapability", -1);
+
+            pvalue->u.h263VideoCapability = ALLOC_ASN1ELEM (pctxt, H245H263VideoCapability);
+
+            stat = asn1PD_H245H263VideoCapability (pctxt, pvalue->u.h263VideoCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h263VideoCapability", -1);
+
+            break;
+
+         /* is11172VideoCapability */
+         case 4:
+            invokeStartElement (pctxt, "is11172VideoCapability", -1);
+
+            pvalue->u.is11172VideoCapability = ALLOC_ASN1ELEM (pctxt, H245IS11172VideoCapability);
+
+            stat = asn1PD_H245IS11172VideoCapability (pctxt, pvalue->u.is11172VideoCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "is11172VideoCapability", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* genericVideoCapability */
+         case 6:
+            invokeStartElement (pctxt, "genericVideoCapability", -1);
+
+            pvalue->u.genericVideoCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability);
+
+            stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericVideoCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericVideoCapability", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioCapability_g7231                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245AudioCapability_g7231 (OOCTXT* pctxt, H245AudioCapability_g7231* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode maxAl_sduAudioFrames */
+
+   invokeStartElement (pctxt, "maxAl_sduAudioFrames", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maxAl_sduAudioFrames, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxAl_sduAudioFrames);
+
+   invokeEndElement (pctxt, "maxAl_sduAudioFrames", -1);
+
+   /* decode silenceSuppression */
+
+   invokeStartElement (pctxt, "silenceSuppression", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->silenceSuppression);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->silenceSuppression);
+
+   invokeEndElement (pctxt, "silenceSuppression", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS11172AudioCapability (OOCTXT* pctxt, H245IS11172AudioCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode audioLayer1 */
+
+   invokeStartElement (pctxt, "audioLayer1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioLayer1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioLayer1);
+
+   invokeEndElement (pctxt, "audioLayer1", -1);
+
+   /* decode audioLayer2 */
+
+   invokeStartElement (pctxt, "audioLayer2", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioLayer2);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioLayer2);
+
+   invokeEndElement (pctxt, "audioLayer2", -1);
+
+   /* decode audioLayer3 */
+
+   invokeStartElement (pctxt, "audioLayer3", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioLayer3);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioLayer3);
+
+   invokeEndElement (pctxt, "audioLayer3", -1);
+
+   /* decode audioSampling32k */
+
+   invokeStartElement (pctxt, "audioSampling32k", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling32k);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling32k);
+
+   invokeEndElement (pctxt, "audioSampling32k", -1);
+
+   /* decode audioSampling44k1 */
+
+   invokeStartElement (pctxt, "audioSampling44k1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling44k1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling44k1);
+
+   invokeEndElement (pctxt, "audioSampling44k1", -1);
+
+   /* decode audioSampling48k */
+
+   invokeStartElement (pctxt, "audioSampling48k", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling48k);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling48k);
+
+   invokeEndElement (pctxt, "audioSampling48k", -1);
+
+   /* decode singleChannel */
+
+   invokeStartElement (pctxt, "singleChannel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->singleChannel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->singleChannel);
+
+   invokeEndElement (pctxt, "singleChannel", -1);
+
+   /* decode twoChannels */
+
+   invokeStartElement (pctxt, "twoChannels", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->twoChannels);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->twoChannels);
+
+   invokeEndElement (pctxt, "twoChannels", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 448U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS13818AudioCapability (OOCTXT* pctxt, H245IS13818AudioCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode audioLayer1 */
+
+   invokeStartElement (pctxt, "audioLayer1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioLayer1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioLayer1);
+
+   invokeEndElement (pctxt, "audioLayer1", -1);
+
+   /* decode audioLayer2 */
+
+   invokeStartElement (pctxt, "audioLayer2", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioLayer2);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioLayer2);
+
+   invokeEndElement (pctxt, "audioLayer2", -1);
+
+   /* decode audioLayer3 */
+
+   invokeStartElement (pctxt, "audioLayer3", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioLayer3);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioLayer3);
+
+   invokeEndElement (pctxt, "audioLayer3", -1);
+
+   /* decode audioSampling16k */
+
+   invokeStartElement (pctxt, "audioSampling16k", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling16k);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling16k);
+
+   invokeEndElement (pctxt, "audioSampling16k", -1);
+
+   /* decode audioSampling22k05 */
+
+   invokeStartElement (pctxt, "audioSampling22k05", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling22k05);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling22k05);
+
+   invokeEndElement (pctxt, "audioSampling22k05", -1);
+
+   /* decode audioSampling24k */
+
+   invokeStartElement (pctxt, "audioSampling24k", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling24k);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling24k);
+
+   invokeEndElement (pctxt, "audioSampling24k", -1);
+
+   /* decode audioSampling32k */
+
+   invokeStartElement (pctxt, "audioSampling32k", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling32k);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling32k);
+
+   invokeEndElement (pctxt, "audioSampling32k", -1);
+
+   /* decode audioSampling44k1 */
+
+   invokeStartElement (pctxt, "audioSampling44k1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling44k1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling44k1);
+
+   invokeEndElement (pctxt, "audioSampling44k1", -1);
+
+   /* decode audioSampling48k */
+
+   invokeStartElement (pctxt, "audioSampling48k", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioSampling48k);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioSampling48k);
+
+   invokeEndElement (pctxt, "audioSampling48k", -1);
+
+   /* decode singleChannel */
+
+   invokeStartElement (pctxt, "singleChannel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->singleChannel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->singleChannel);
+
+   invokeEndElement (pctxt, "singleChannel", -1);
+
+   /* decode twoChannels */
+
+   invokeStartElement (pctxt, "twoChannels", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->twoChannels);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->twoChannels);
+
+   invokeEndElement (pctxt, "twoChannels", -1);
+
+   /* decode threeChannels2_1 */
+
+   invokeStartElement (pctxt, "threeChannels2_1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->threeChannels2_1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->threeChannels2_1);
+
+   invokeEndElement (pctxt, "threeChannels2_1", -1);
+
+   /* decode threeChannels3_0 */
+
+   invokeStartElement (pctxt, "threeChannels3_0", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->threeChannels3_0);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->threeChannels3_0);
+
+   invokeEndElement (pctxt, "threeChannels3_0", -1);
+
+   /* decode fourChannels2_0_2_0 */
+
+   invokeStartElement (pctxt, "fourChannels2_0_2_0", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fourChannels2_0_2_0);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fourChannels2_0_2_0);
+
+   invokeEndElement (pctxt, "fourChannels2_0_2_0", -1);
+
+   /* decode fourChannels2_2 */
+
+   invokeStartElement (pctxt, "fourChannels2_2", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fourChannels2_2);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fourChannels2_2);
+
+   invokeEndElement (pctxt, "fourChannels2_2", -1);
+
+   /* decode fourChannels3_1 */
+
+   invokeStartElement (pctxt, "fourChannels3_1", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fourChannels3_1);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fourChannels3_1);
+
+   invokeEndElement (pctxt, "fourChannels3_1", -1);
+
+   /* decode fiveChannels3_0_2_0 */
+
+   invokeStartElement (pctxt, "fiveChannels3_0_2_0", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fiveChannels3_0_2_0);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fiveChannels3_0_2_0);
+
+   invokeEndElement (pctxt, "fiveChannels3_0_2_0", -1);
+
+   /* decode fiveChannels3_2 */
+
+   invokeStartElement (pctxt, "fiveChannels3_2", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->fiveChannels3_2);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->fiveChannels3_2);
+
+   invokeEndElement (pctxt, "fiveChannels3_2", -1);
+
+   /* decode lowFrequencyEnhancement */
+
+   invokeStartElement (pctxt, "lowFrequencyEnhancement", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->lowFrequencyEnhancement);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->lowFrequencyEnhancement);
+
+   invokeEndElement (pctxt, "lowFrequencyEnhancement", -1);
+
+   /* decode multilingual */
+
+   invokeStartElement (pctxt, "multilingual", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->multilingual);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->multilingual);
+
+   invokeEndElement (pctxt, "multilingual", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 1130U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCCapability_g723AnnexCAudioMode                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245G7231AnnexCCapability_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCCapability_g723AnnexCAudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode highRateMode0 */
+
+   invokeStartElement (pctxt, "highRateMode0", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->highRateMode0, 27U, 78U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->highRateMode0);
+
+   invokeEndElement (pctxt, "highRateMode0", -1);
+
+   /* decode highRateMode1 */
+
+   invokeStartElement (pctxt, "highRateMode1", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->highRateMode1, 27U, 78U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->highRateMode1);
+
+   invokeEndElement (pctxt, "highRateMode1", -1);
+
+   /* decode lowRateMode0 */
+
+   invokeStartElement (pctxt, "lowRateMode0", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->lowRateMode0, 23U, 66U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->lowRateMode0);
+
+   invokeEndElement (pctxt, "lowRateMode0", -1);
+
+   /* decode lowRateMode1 */
+
+   invokeStartElement (pctxt, "lowRateMode1", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->lowRateMode1, 23U, 66U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->lowRateMode1);
+
+   invokeEndElement (pctxt, "lowRateMode1", -1);
+
+   /* decode sidMode0 */
+
+   invokeStartElement (pctxt, "sidMode0", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sidMode0, 6U, 17U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sidMode0);
+
+   invokeEndElement (pctxt, "sidMode0", -1);
+
+   /* decode sidMode1 */
+
+   invokeStartElement (pctxt, "sidMode1", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sidMode1, 6U, 17U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sidMode1);
+
+   invokeEndElement (pctxt, "sidMode1", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCCapability                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245G7231AnnexCCapability (OOCTXT* pctxt, H245G7231AnnexCCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.g723AnnexCAudioModePresent = optbit;
+
+   /* decode maxAl_sduAudioFrames */
+
+   invokeStartElement (pctxt, "maxAl_sduAudioFrames", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maxAl_sduAudioFrames, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxAl_sduAudioFrames);
+
+   invokeEndElement (pctxt, "maxAl_sduAudioFrames", -1);
+
+   /* decode silenceSuppression */
+
+   invokeStartElement (pctxt, "silenceSuppression", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->silenceSuppression);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->silenceSuppression);
+
+   invokeEndElement (pctxt, "silenceSuppression", -1);
+
+   /* decode g723AnnexCAudioMode */
+
+   if (pvalue->m.g723AnnexCAudioModePresent) {
+      invokeStartElement (pctxt, "g723AnnexCAudioMode", -1);
+
+      stat = asn1PD_H245G7231AnnexCCapability_g723AnnexCAudioMode (pctxt, &pvalue->g723AnnexCAudioMode);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "g723AnnexCAudioMode", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GSMAudioCapability                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245GSMAudioCapability (OOCTXT* pctxt, H245GSMAudioCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode audioUnitSize */
+
+   invokeStartElement (pctxt, "audioUnitSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->audioUnitSize, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->audioUnitSize);
+
+   invokeEndElement (pctxt, "audioUnitSize", -1);
+
+   /* decode comfortNoise */
+
+   invokeStartElement (pctxt, "comfortNoise", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->comfortNoise);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->comfortNoise);
+
+   invokeEndElement (pctxt, "comfortNoise", -1);
+
+   /* decode scrambled */
+
+   invokeStartElement (pctxt, "scrambled", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->scrambled);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->scrambled);
+
+   invokeEndElement (pctxt, "scrambled", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G729Extensions                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245G729Extensions (OOCTXT* pctxt, H245G729Extensions* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.audioUnitPresent = optbit;
+
+   /* decode audioUnit */
+
+   if (pvalue->m.audioUnitPresent) {
+      invokeStartElement (pctxt, "audioUnit", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->audioUnit, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->audioUnit);
+
+      invokeEndElement (pctxt, "audioUnit", -1);
+   }
+
+   /* decode annexA */
+
+   invokeStartElement (pctxt, "annexA", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->annexA);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->annexA);
+
+   invokeEndElement (pctxt, "annexA", -1);
+
+   /* decode annexB */
+
+   invokeStartElement (pctxt, "annexB", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->annexB);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->annexB);
+
+   invokeEndElement (pctxt, "annexB", -1);
+
+   /* decode annexD */
+
+   invokeStartElement (pctxt, "annexD", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->annexD);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->annexD);
+
+   invokeEndElement (pctxt, "annexD", -1);
+
+   /* decode annexE */
+
+   invokeStartElement (pctxt, "annexE", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->annexE);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->annexE);
+
+   invokeEndElement (pctxt, "annexE", -1);
+
+   /* decode annexF */
+
+   invokeStartElement (pctxt, "annexF", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->annexF);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->annexF);
+
+   invokeEndElement (pctxt, "annexF", -1);
+
+   /* decode annexG */
+
+   invokeStartElement (pctxt, "annexG", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->annexG);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->annexG);
+
+   invokeEndElement (pctxt, "annexG", -1);
+
+   /* decode annexH */
+
+   invokeStartElement (pctxt, "annexH", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->annexH);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->annexH);
+
+   invokeEndElement (pctxt, "annexH", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VBDCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VBDCapability (OOCTXT* pctxt, H245VBDCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   pvalue->type = ALLOC_ASN1ELEM (pctxt, H245AudioCapability);
+
+   stat = asn1PD_H245AudioCapability (pctxt, (H245AudioCapability*)pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NoPTAudioTelephonyEventCapability                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NoPTAudioTelephonyEventCapability (OOCTXT* pctxt, H245NoPTAudioTelephonyEventCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode audioTelephoneEvent */
+
+   invokeStartElement (pctxt, "audioTelephoneEvent", -1);
+
+   stat = decodeVarWidthCharString (pctxt, &pvalue->audioTelephoneEvent);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, pvalue->audioTelephoneEvent);
+
+   invokeEndElement (pctxt, "audioTelephoneEvent", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NoPTAudioToneCapability                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NoPTAudioToneCapability (OOCTXT* pctxt, H245NoPTAudioToneCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioCapability                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245AudioCapability (OOCTXT* pctxt, H245AudioCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 13);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* g711Alaw64k */
+         case 1:
+            invokeStartElement (pctxt, "g711Alaw64k", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g711Alaw64k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g711Alaw64k);
+
+            invokeEndElement (pctxt, "g711Alaw64k", -1);
+
+            break;
+
+         /* g711Alaw56k */
+         case 2:
+            invokeStartElement (pctxt, "g711Alaw56k", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g711Alaw56k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g711Alaw56k);
+
+            invokeEndElement (pctxt, "g711Alaw56k", -1);
+
+            break;
+
+         /* g711Ulaw64k */
+         case 3:
+            invokeStartElement (pctxt, "g711Ulaw64k", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g711Ulaw64k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g711Ulaw64k);
+
+            invokeEndElement (pctxt, "g711Ulaw64k", -1);
+
+            break;
+
+         /* g711Ulaw56k */
+         case 4:
+            invokeStartElement (pctxt, "g711Ulaw56k", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g711Ulaw56k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g711Ulaw56k);
+
+            invokeEndElement (pctxt, "g711Ulaw56k", -1);
+
+            break;
+
+         /* g722_64k */
+         case 5:
+            invokeStartElement (pctxt, "g722_64k", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g722_64k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g722_64k);
+
+            invokeEndElement (pctxt, "g722_64k", -1);
+
+            break;
+
+         /* g722_56k */
+         case 6:
+            invokeStartElement (pctxt, "g722_56k", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g722_56k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g722_56k);
+
+            invokeEndElement (pctxt, "g722_56k", -1);
+
+            break;
+
+         /* g722_48k */
+         case 7:
+            invokeStartElement (pctxt, "g722_48k", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g722_48k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g722_48k);
+
+            invokeEndElement (pctxt, "g722_48k", -1);
+
+            break;
+
+         /* g7231 */
+         case 8:
+            invokeStartElement (pctxt, "g7231", -1);
+
+            pvalue->u.g7231 = ALLOC_ASN1ELEM (pctxt, H245AudioCapability_g7231);
+
+            stat = asn1PD_H245AudioCapability_g7231 (pctxt, pvalue->u.g7231);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "g7231", -1);
+
+            break;
+
+         /* g728 */
+         case 9:
+            invokeStartElement (pctxt, "g728", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g728, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g728);
+
+            invokeEndElement (pctxt, "g728", -1);
+
+            break;
+
+         /* g729 */
+         case 10:
+            invokeStartElement (pctxt, "g729", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g729, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g729);
+
+            invokeEndElement (pctxt, "g729", -1);
+
+            break;
+
+         /* g729AnnexA */
+         case 11:
+            invokeStartElement (pctxt, "g729AnnexA", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g729AnnexA, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g729AnnexA);
+
+            invokeEndElement (pctxt, "g729AnnexA", -1);
+
+            break;
+
+         /* is11172AudioCapability */
+         case 12:
+            invokeStartElement (pctxt, "is11172AudioCapability", -1);
+
+            pvalue->u.is11172AudioCapability = ALLOC_ASN1ELEM (pctxt, H245IS11172AudioCapability);
+
+            stat = asn1PD_H245IS11172AudioCapability (pctxt, pvalue->u.is11172AudioCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "is11172AudioCapability", -1);
+
+            break;
+
+         /* is13818AudioCapability */
+         case 13:
+            invokeStartElement (pctxt, "is13818AudioCapability", -1);
+
+            pvalue->u.is13818AudioCapability = ALLOC_ASN1ELEM (pctxt, H245IS13818AudioCapability);
+
+            stat = asn1PD_H245IS13818AudioCapability (pctxt, pvalue->u.is13818AudioCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "is13818AudioCapability", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 15;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* g729wAnnexB */
+         case 15:
+            invokeStartElement (pctxt, "g729wAnnexB", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g729wAnnexB, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g729wAnnexB);
+
+            invokeEndElement (pctxt, "g729wAnnexB", -1);
+
+            break;
+
+         /* g729AnnexAwAnnexB */
+         case 16:
+            invokeStartElement (pctxt, "g729AnnexAwAnnexB", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g729AnnexAwAnnexB, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g729AnnexAwAnnexB);
+
+            invokeEndElement (pctxt, "g729AnnexAwAnnexB", -1);
+
+            break;
+
+         /* g7231AnnexCCapability */
+         case 17:
+            invokeStartElement (pctxt, "g7231AnnexCCapability", -1);
+
+            pvalue->u.g7231AnnexCCapability = ALLOC_ASN1ELEM (pctxt, H245G7231AnnexCCapability);
+
+            stat = asn1PD_H245G7231AnnexCCapability (pctxt, pvalue->u.g7231AnnexCCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "g7231AnnexCCapability", -1);
+
+            break;
+
+         /* gsmFullRate */
+         case 18:
+            invokeStartElement (pctxt, "gsmFullRate", -1);
+
+            pvalue->u.gsmFullRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability);
+
+            stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmFullRate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gsmFullRate", -1);
+
+            break;
+
+         /* gsmHalfRate */
+         case 19:
+            invokeStartElement (pctxt, "gsmHalfRate", -1);
+
+            pvalue->u.gsmHalfRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability);
+
+            stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmHalfRate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gsmHalfRate", -1);
+
+            break;
+
+         /* gsmEnhancedFullRate */
+         case 20:
+            invokeStartElement (pctxt, "gsmEnhancedFullRate", -1);
+
+            pvalue->u.gsmEnhancedFullRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability);
+
+            stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmEnhancedFullRate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gsmEnhancedFullRate", -1);
+
+            break;
+
+         /* genericAudioCapability */
+         case 21:
+            invokeStartElement (pctxt, "genericAudioCapability", -1);
+
+            pvalue->u.genericAudioCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability);
+
+            stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericAudioCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericAudioCapability", -1);
+
+            break;
+
+         /* g729Extensions */
+         case 22:
+            invokeStartElement (pctxt, "g729Extensions", -1);
+
+            pvalue->u.g729Extensions = ALLOC_ASN1ELEM (pctxt, H245G729Extensions);
+
+            stat = asn1PD_H245G729Extensions (pctxt, pvalue->u.g729Extensions);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "g729Extensions", -1);
+
+            break;
+
+         /* vbd */
+         case 23:
+            invokeStartElement (pctxt, "vbd", -1);
+
+            pvalue->u.vbd = ALLOC_ASN1ELEM (pctxt, H245VBDCapability);
+
+            stat = asn1PD_H245VBDCapability (pctxt, pvalue->u.vbd);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "vbd", -1);
+
+            break;
+
+         /* audioTelephonyEvent */
+         case 24:
+            invokeStartElement (pctxt, "audioTelephonyEvent", -1);
+
+            pvalue->u.audioTelephonyEvent = ALLOC_ASN1ELEM (pctxt, H245NoPTAudioTelephonyEventCapability);
+
+            stat = asn1PD_H245NoPTAudioTelephonyEventCapability (pctxt, pvalue->u.audioTelephonyEvent);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioTelephonyEvent", -1);
+
+            break;
+
+         /* audioTone */
+         case 25:
+            invokeStartElement (pctxt, "audioTone", -1);
+
+            pvalue->u.audioTone = ALLOC_ASN1ELEM (pctxt, H245NoPTAudioToneCapability);
+
+            stat = asn1PD_H245NoPTAudioToneCapability (pctxt, pvalue->u.audioTone);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioTone", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Capability_h233EncryptionReceiveCapability                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245Capability_h233EncryptionReceiveCapability (OOCTXT* pctxt, H245Capability_h233EncryptionReceiveCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode h233IVResponseTime */
+
+   invokeStartElement (pctxt, "h233IVResponseTime", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->h233IVResponseTime, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->h233IVResponseTime);
+
+   invokeEndElement (pctxt, "h233IVResponseTime", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245NonStandardParameter                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245NonStandardParameter (OOCTXT* pctxt, H245_SeqOfH245NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+   H245NonStandardParameter* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245NonStandardParameter);
+
+         stat = asn1PD_H245NonStandardParameter (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceCapability (OOCTXT* pctxt, H245ConferenceCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardDataPresent = optbit;
+
+   /* decode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      invokeStartElement (pctxt, "nonStandardData", -1);
+
+      stat = asn1PD_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandardData", -1);
+   }
+
+   /* decode chairControlCapability */
+
+   invokeStartElement (pctxt, "chairControlCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->chairControlCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->chairControlCapability);
+
+   invokeEndElement (pctxt, "chairControlCapability", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.videoIndicateMixingCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "videoIndicateMixingCapability", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->videoIndicateMixingCapability);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->videoIndicateMixingCapability);
+
+                     invokeEndElement (pctxt, "videoIndicateMixingCapability", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.multipointVisualizationCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "multipointVisualizationCapability", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->multipointVisualizationCapability);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->multipointVisualizationCapability);
+
+                     invokeEndElement (pctxt, "multipointVisualizationCapability", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaEncryptionAlgorithm                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MediaEncryptionAlgorithm (OOCTXT* pctxt, H245MediaEncryptionAlgorithm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* algorithm */
+         case 1:
+            invokeStartElement (pctxt, "algorithm", -1);
+
+            pvalue->u.algorithm = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
+
+            stat = decodeObjectIdentifier (pctxt, pvalue->u.algorithm);
+            if (stat != ASN_OK) return stat;
+            invokeOidValue (pctxt, pvalue->u.algorithm->numids, pvalue->u.algorithm->subid);
+
+            invokeEndElement (pctxt, "algorithm", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EncryptionCapability (OOCTXT* pctxt, H245EncryptionCapability* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245MediaEncryptionAlgorithm* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MediaEncryptionAlgorithm);
+
+      stat = asn1PD_H245MediaEncryptionAlgorithm (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationCapability                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245AuthenticationCapability (OOCTXT* pctxt, H245AuthenticationCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.antiSpamAlgorithmPresent = 1;
+
+                     invokeStartElement (pctxt, "antiSpamAlgorithm", -1);
+
+                     stat = decodeObjectIdentifier (pctxt, &pvalue->antiSpamAlgorithm);
+                     if (stat != ASN_OK) return stat;
+                     invokeOidValue (pctxt, pvalue->antiSpamAlgorithm.numids, pvalue->antiSpamAlgorithm.subid);
+
+                     invokeEndElement (pctxt, "antiSpamAlgorithm", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IntegrityCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IntegrityCapability (OOCTXT* pctxt, H245IntegrityCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionAuthenticationAndIntegrity                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EncryptionAuthenticationAndIntegrity (OOCTXT* pctxt, H245EncryptionAuthenticationAndIntegrity* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.encryptionCapabilityPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.authenticationCapabilityPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.integrityCapabilityPresent = optbit;
+
+   /* decode encryptionCapability */
+
+   if (pvalue->m.encryptionCapabilityPresent) {
+      invokeStartElement (pctxt, "encryptionCapability", -1);
+
+      stat = asn1PD_H245EncryptionCapability (pctxt, &pvalue->encryptionCapability);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "encryptionCapability", -1);
+   }
+
+   /* decode authenticationCapability */
+
+   if (pvalue->m.authenticationCapabilityPresent) {
+      invokeStartElement (pctxt, "authenticationCapability", -1);
+
+      stat = asn1PD_H245AuthenticationCapability (pctxt, &pvalue->authenticationCapability);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "authenticationCapability", -1);
+   }
+
+   /* decode integrityCapability */
+
+   if (pvalue->m.integrityCapabilityPresent) {
+      invokeStartElement (pctxt, "integrityCapability", -1);
+
+      stat = asn1PD_H245IntegrityCapability (pctxt, &pvalue->integrityCapability);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "integrityCapability", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235SecurityCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H235SecurityCapability (OOCTXT* pctxt, H245H235SecurityCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode encryptionAuthenticationAndIntegrity */
+
+   invokeStartElement (pctxt, "encryptionAuthenticationAndIntegrity", -1);
+
+   stat = asn1PD_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "encryptionAuthenticationAndIntegrity", -1);
+
+   /* decode mediaCapability */
+
+   invokeStartElement (pctxt, "mediaCapability", -1);
+
+   stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->mediaCapability);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mediaCapability", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputCapability_nonStandard                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UserInputCapability_nonStandard (OOCTXT* pctxt, H245UserInputCapability_nonStandard* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   H245NonStandardParameter* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245NonStandardParameter);
+
+      stat = asn1PD_H245NonStandardParameter (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UserInputCapability (OOCTXT* pctxt, H245UserInputCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245UserInputCapability_nonStandard);
+
+            stat = asn1PD_H245UserInputCapability_nonStandard (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* basicString */
+         case 1:
+            invokeStartElement (pctxt, "basicString", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "basicString", -1);
+
+            break;
+
+         /* iA5String */
+         case 2:
+            invokeStartElement (pctxt, "iA5String", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "iA5String", -1);
+
+            break;
+
+         /* generalString */
+         case 3:
+            invokeStartElement (pctxt, "generalString", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "generalString", -1);
+
+            break;
+
+         /* dtmf */
+         case 4:
+            invokeStartElement (pctxt, "dtmf", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "dtmf", -1);
+
+            break;
+
+         /* hookflash */
+         case 5:
+            invokeStartElement (pctxt, "hookflash", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "hookflash", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* extendedAlphanumeric */
+         case 7:
+            invokeStartElement (pctxt, "extendedAlphanumeric", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "extendedAlphanumeric", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexFormat                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexFormat (OOCTXT* pctxt, H245MultiplexFormat* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* h222Capability */
+         case 1:
+            invokeStartElement (pctxt, "h222Capability", -1);
+
+            pvalue->u.h222Capability = ALLOC_ASN1ELEM (pctxt, H245H222Capability);
+
+            stat = asn1PD_H245H222Capability (pctxt, pvalue->u.h222Capability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h222Capability", -1);
+
+            break;
+
+         /* h223Capability */
+         case 2:
+            invokeStartElement (pctxt, "h223Capability", -1);
+
+            pvalue->u.h223Capability = ALLOC_ASN1ELEM (pctxt, H245H223Capability);
+
+            stat = asn1PD_H245H223Capability (pctxt, pvalue->u.h223Capability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h223Capability", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AlternativeCapabilitySet                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245AlternativeCapabilitySet (OOCTXT* pctxt, H245AlternativeCapabilitySet* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamCapability_capabilityOnMuxStream         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexedStreamCapability_capabilityOnMuxStream (OOCTXT* pctxt, H245MultiplexedStreamCapability_capabilityOnMuxStream* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245AlternativeCapabilitySet* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245AlternativeCapabilitySet);
+
+      stat = asn1PD_H245AlternativeCapabilitySet (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamCapability                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexedStreamCapability (OOCTXT* pctxt, H245MultiplexedStreamCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.capabilityOnMuxStreamPresent = optbit;
+
+   /* decode multiplexFormat */
+
+   invokeStartElement (pctxt, "multiplexFormat", -1);
+
+   stat = asn1PD_H245MultiplexFormat (pctxt, &pvalue->multiplexFormat);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexFormat", -1);
+
+   /* decode controlOnMuxStream */
+
+   invokeStartElement (pctxt, "controlOnMuxStream", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->controlOnMuxStream);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->controlOnMuxStream);
+
+   invokeEndElement (pctxt, "controlOnMuxStream", -1);
+
+   /* decode capabilityOnMuxStream */
+
+   if (pvalue->m.capabilityOnMuxStreamPresent) {
+      invokeStartElement (pctxt, "capabilityOnMuxStream", -1);
+
+      stat = asn1PD_H245MultiplexedStreamCapability_capabilityOnMuxStream (pctxt, &pvalue->capabilityOnMuxStream);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "capabilityOnMuxStream", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioTelephonyEventCapability                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245AudioTelephonyEventCapability (OOCTXT* pctxt, H245AudioTelephonyEventCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode dynamicRTPPayloadType */
+
+   invokeStartElement (pctxt, "dynamicRTPPayloadType", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->dynamicRTPPayloadType, 96U, 127U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->dynamicRTPPayloadType);
+
+   invokeEndElement (pctxt, "dynamicRTPPayloadType", -1);
+
+   /* decode audioTelephoneEvent */
+
+   invokeStartElement (pctxt, "audioTelephoneEvent", -1);
+
+   stat = decodeVarWidthCharString (pctxt, &pvalue->audioTelephoneEvent);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, pvalue->audioTelephoneEvent);
+
+   invokeEndElement (pctxt, "audioTelephoneEvent", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioToneCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245AudioToneCapability (OOCTXT* pctxt, H245AudioToneCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode dynamicRTPPayloadType */
+
+   invokeStartElement (pctxt, "dynamicRTPPayloadType", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->dynamicRTPPayloadType, 96U, 127U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->dynamicRTPPayloadType);
+
+   invokeEndElement (pctxt, "dynamicRTPPayloadType", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability_rfc2733_separateStream                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECCapability_rfc2733_separateStream (OOCTXT* pctxt, H245FECCapability_rfc2733_separateStream* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode separatePort */
+
+   invokeStartElement (pctxt, "separatePort", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->separatePort);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->separatePort);
+
+   invokeEndElement (pctxt, "separatePort", -1);
+
+   /* decode samePort */
+
+   invokeStartElement (pctxt, "samePort", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->samePort);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->samePort);
+
+   invokeEndElement (pctxt, "samePort", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability_rfc2733                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECCapability_rfc2733 (OOCTXT* pctxt, H245FECCapability_rfc2733* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode redundancyEncoding */
+
+   invokeStartElement (pctxt, "redundancyEncoding", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->redundancyEncoding);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->redundancyEncoding);
+
+   invokeEndElement (pctxt, "redundancyEncoding", -1);
+
+   /* decode separateStream */
+
+   invokeStartElement (pctxt, "separateStream", -1);
+
+   stat = asn1PD_H245FECCapability_rfc2733_separateStream (pctxt, &pvalue->separateStream);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "separateStream", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECCapability (OOCTXT* pctxt, H245FECCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* rfc2733 */
+         case 0:
+            invokeStartElement (pctxt, "rfc2733", -1);
+
+            pvalue->u.rfc2733 = ALLOC_ASN1ELEM (pctxt, H245FECCapability_rfc2733);
+
+            stat = asn1PD_H245FECCapability_rfc2733 (pctxt, pvalue->u.rfc2733);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "rfc2733", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamCapability_capabilities              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplePayloadStreamCapability_capabilities (OOCTXT* pctxt, H245MultiplePayloadStreamCapability_capabilities* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245AlternativeCapabilitySet* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245AlternativeCapabilitySet);
+
+      stat = asn1PD_H245AlternativeCapabilitySet (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamCapability                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplePayloadStreamCapability (OOCTXT* pctxt, H245MultiplePayloadStreamCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode capabilities */
+
+   invokeStartElement (pctxt, "capabilities", -1);
+
+   stat = asn1PD_H245MultiplePayloadStreamCapability_capabilities (pctxt, &pvalue->capabilities);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "capabilities", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Capability                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245Capability (OOCTXT* pctxt, H245Capability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 11);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* receiveVideoCapability */
+         case 1:
+            invokeStartElement (pctxt, "receiveVideoCapability", -1);
+
+            pvalue->u.receiveVideoCapability = ALLOC_ASN1ELEM (pctxt, H245VideoCapability);
+
+            stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.receiveVideoCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveVideoCapability", -1);
+
+            break;
+
+         /* transmitVideoCapability */
+         case 2:
+            invokeStartElement (pctxt, "transmitVideoCapability", -1);
+
+            pvalue->u.transmitVideoCapability = ALLOC_ASN1ELEM (pctxt, H245VideoCapability);
+
+            stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.transmitVideoCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transmitVideoCapability", -1);
+
+            break;
+
+         /* receiveAndTransmitVideoCapability */
+         case 3:
+            invokeStartElement (pctxt, "receiveAndTransmitVideoCapability", -1);
+
+            pvalue->u.receiveAndTransmitVideoCapability = ALLOC_ASN1ELEM (pctxt, H245VideoCapability);
+
+            stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.receiveAndTransmitVideoCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveAndTransmitVideoCapability", -1);
+
+            break;
+
+         /* receiveAudioCapability */
+         case 4:
+            invokeStartElement (pctxt, "receiveAudioCapability", -1);
+
+            pvalue->u.receiveAudioCapability = ALLOC_ASN1ELEM (pctxt, H245AudioCapability);
+
+            stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.receiveAudioCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveAudioCapability", -1);
+
+            break;
+
+         /* transmitAudioCapability */
+         case 5:
+            invokeStartElement (pctxt, "transmitAudioCapability", -1);
+
+            pvalue->u.transmitAudioCapability = ALLOC_ASN1ELEM (pctxt, H245AudioCapability);
+
+            stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.transmitAudioCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transmitAudioCapability", -1);
+
+            break;
+
+         /* receiveAndTransmitAudioCapability */
+         case 6:
+            invokeStartElement (pctxt, "receiveAndTransmitAudioCapability", -1);
+
+            pvalue->u.receiveAndTransmitAudioCapability = ALLOC_ASN1ELEM (pctxt, H245AudioCapability);
+
+            stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.receiveAndTransmitAudioCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveAndTransmitAudioCapability", -1);
+
+            break;
+
+         /* receiveDataApplicationCapability */
+         case 7:
+            invokeStartElement (pctxt, "receiveDataApplicationCapability", -1);
+
+            pvalue->u.receiveDataApplicationCapability = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability);
+
+            stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.receiveDataApplicationCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveDataApplicationCapability", -1);
+
+            break;
+
+         /* transmitDataApplicationCapability */
+         case 8:
+            invokeStartElement (pctxt, "transmitDataApplicationCapability", -1);
+
+            pvalue->u.transmitDataApplicationCapability = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability);
+
+            stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.transmitDataApplicationCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transmitDataApplicationCapability", -1);
+
+            break;
+
+         /* receiveAndTransmitDataApplicationCapability */
+         case 9:
+            invokeStartElement (pctxt, "receiveAndTransmitDataApplicationCapability", -1);
+
+            pvalue->u.receiveAndTransmitDataApplicationCapability = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability);
+
+            stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.receiveAndTransmitDataApplicationCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveAndTransmitDataApplicationCapability", -1);
+
+            break;
+
+         /* h233EncryptionTransmitCapability */
+         case 10:
+            invokeStartElement (pctxt, "h233EncryptionTransmitCapability", -1);
+
+            stat = DECODEBIT (pctxt, &pvalue->u.h233EncryptionTransmitCapability);
+            if (stat != ASN_OK) return stat;
+            invokeBoolValue (pctxt, pvalue->u.h233EncryptionTransmitCapability);
+
+            invokeEndElement (pctxt, "h233EncryptionTransmitCapability", -1);
+
+            break;
+
+         /* h233EncryptionReceiveCapability */
+         case 11:
+            invokeStartElement (pctxt, "h233EncryptionReceiveCapability", -1);
+
+            pvalue->u.h233EncryptionReceiveCapability = ALLOC_ASN1ELEM (pctxt, H245Capability_h233EncryptionReceiveCapability);
+
+            stat = asn1PD_H245Capability_h233EncryptionReceiveCapability (pctxt, pvalue->u.h233EncryptionReceiveCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h233EncryptionReceiveCapability", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 13;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* conferenceCapability */
+         case 13:
+            invokeStartElement (pctxt, "conferenceCapability", -1);
+
+            pvalue->u.conferenceCapability = ALLOC_ASN1ELEM (pctxt, H245ConferenceCapability);
+
+            stat = asn1PD_H245ConferenceCapability (pctxt, pvalue->u.conferenceCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "conferenceCapability", -1);
+
+            break;
+
+         /* h235SecurityCapability */
+         case 14:
+            invokeStartElement (pctxt, "h235SecurityCapability", -1);
+
+            pvalue->u.h235SecurityCapability = ALLOC_ASN1ELEM (pctxt, H245H235SecurityCapability);
+
+            stat = asn1PD_H245H235SecurityCapability (pctxt, pvalue->u.h235SecurityCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h235SecurityCapability", -1);
+
+            break;
+
+         /* maxPendingReplacementFor */
+         case 15:
+            invokeStartElement (pctxt, "maxPendingReplacementFor", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.maxPendingReplacementFor, 0U, 255U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.maxPendingReplacementFor);
+
+            invokeEndElement (pctxt, "maxPendingReplacementFor", -1);
+
+            break;
+
+         /* receiveUserInputCapability */
+         case 16:
+            invokeStartElement (pctxt, "receiveUserInputCapability", -1);
+
+            pvalue->u.receiveUserInputCapability = ALLOC_ASN1ELEM (pctxt, H245UserInputCapability);
+
+            stat = asn1PD_H245UserInputCapability (pctxt, pvalue->u.receiveUserInputCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveUserInputCapability", -1);
+
+            break;
+
+         /* transmitUserInputCapability */
+         case 17:
+            invokeStartElement (pctxt, "transmitUserInputCapability", -1);
+
+            pvalue->u.transmitUserInputCapability = ALLOC_ASN1ELEM (pctxt, H245UserInputCapability);
+
+            stat = asn1PD_H245UserInputCapability (pctxt, pvalue->u.transmitUserInputCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transmitUserInputCapability", -1);
+
+            break;
+
+         /* receiveAndTransmitUserInputCapability */
+         case 18:
+            invokeStartElement (pctxt, "receiveAndTransmitUserInputCapability", -1);
+
+            pvalue->u.receiveAndTransmitUserInputCapability = ALLOC_ASN1ELEM (pctxt, H245UserInputCapability);
+
+            stat = asn1PD_H245UserInputCapability (pctxt, pvalue->u.receiveAndTransmitUserInputCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveAndTransmitUserInputCapability", -1);
+
+            break;
+
+         /* genericControlCapability */
+         case 19:
+            invokeStartElement (pctxt, "genericControlCapability", -1);
+
+            pvalue->u.genericControlCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability);
+
+            stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericControlCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericControlCapability", -1);
+
+            break;
+
+         /* receiveMultiplexedStreamCapability */
+         case 20:
+            invokeStartElement (pctxt, "receiveMultiplexedStreamCapability", -1);
+
+            pvalue->u.receiveMultiplexedStreamCapability = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamCapability);
+
+            stat = asn1PD_H245MultiplexedStreamCapability (pctxt, pvalue->u.receiveMultiplexedStreamCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveMultiplexedStreamCapability", -1);
+
+            break;
+
+         /* transmitMultiplexedStreamCapability */
+         case 21:
+            invokeStartElement (pctxt, "transmitMultiplexedStreamCapability", -1);
+
+            pvalue->u.transmitMultiplexedStreamCapability = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamCapability);
+
+            stat = asn1PD_H245MultiplexedStreamCapability (pctxt, pvalue->u.transmitMultiplexedStreamCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transmitMultiplexedStreamCapability", -1);
+
+            break;
+
+         /* receiveAndTransmitMultiplexedStreamCapability */
+         case 22:
+            invokeStartElement (pctxt, "receiveAndTransmitMultiplexedStreamCapability", -1);
+
+            pvalue->u.receiveAndTransmitMultiplexedStreamCapability = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamCapability);
+
+            stat = asn1PD_H245MultiplexedStreamCapability (pctxt, pvalue->u.receiveAndTransmitMultiplexedStreamCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveAndTransmitMultiplexedStreamCapability", -1);
+
+            break;
+
+         /* receiveRTPAudioTelephonyEventCapability */
+         case 23:
+            invokeStartElement (pctxt, "receiveRTPAudioTelephonyEventCapability", -1);
+
+            pvalue->u.receiveRTPAudioTelephonyEventCapability = ALLOC_ASN1ELEM (pctxt, H245AudioTelephonyEventCapability);
+
+            stat = asn1PD_H245AudioTelephonyEventCapability (pctxt, pvalue->u.receiveRTPAudioTelephonyEventCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveRTPAudioTelephonyEventCapability", -1);
+
+            break;
+
+         /* receiveRTPAudioToneCapability */
+         case 24:
+            invokeStartElement (pctxt, "receiveRTPAudioToneCapability", -1);
+
+            pvalue->u.receiveRTPAudioToneCapability = ALLOC_ASN1ELEM (pctxt, H245AudioToneCapability);
+
+            stat = asn1PD_H245AudioToneCapability (pctxt, pvalue->u.receiveRTPAudioToneCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "receiveRTPAudioToneCapability", -1);
+
+            break;
+
+         /* fecCapability */
+         case 25:
+            invokeStartElement (pctxt, "fecCapability", -1);
+
+            pvalue->u.fecCapability = ALLOC_ASN1ELEM (pctxt, H245FECCapability);
+
+            stat = asn1PD_H245FECCapability (pctxt, pvalue->u.fecCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "fecCapability", -1);
+
+            break;
+
+         /* multiplePayloadStreamCapability */
+         case 26:
+            invokeStartElement (pctxt, "multiplePayloadStreamCapability", -1);
+
+            pvalue->u.multiplePayloadStreamCapability = ALLOC_ASN1ELEM (pctxt, H245MultiplePayloadStreamCapability);
+
+            stat = asn1PD_H245MultiplePayloadStreamCapability (pctxt, pvalue->u.multiplePayloadStreamCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplePayloadStreamCapability", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityTableEntry                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CapabilityTableEntry (OOCTXT* pctxt, H245CapabilityTableEntry* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL optbit;
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.capabilityPresent = optbit;
+
+   /* decode capabilityTableEntryNumber */
+
+   invokeStartElement (pctxt, "capabilityTableEntryNumber", -1);
+
+   stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->capabilityTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "capabilityTableEntryNumber", -1);
+
+   /* decode capability */
+
+   if (pvalue->m.capabilityPresent) {
+      invokeStartElement (pctxt, "capability", -1);
+
+      stat = asn1PD_H245Capability (pctxt, &pvalue->capability);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "capability", -1);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet_capabilityTable                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalCapabilitySet_capabilityTable (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityTable* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245CapabilityTableEntry* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245CapabilityTableEntry);
+
+      stat = asn1PD_H245CapabilityTableEntry (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptorNumber                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CapabilityDescriptorNumber (OOCTXT* pctxt, H245CapabilityDescriptorNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt8 (pctxt, pvalue, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptor_simultaneousCapabilities             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CapabilityDescriptor_simultaneousCapabilities (OOCTXT* pctxt, H245CapabilityDescriptor_simultaneousCapabilities* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245AlternativeCapabilitySet* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245AlternativeCapabilitySet);
+
+      stat = asn1PD_H245AlternativeCapabilitySet (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptor                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CapabilityDescriptor (OOCTXT* pctxt, H245CapabilityDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL optbit;
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.simultaneousCapabilitiesPresent = optbit;
+
+   /* decode capabilityDescriptorNumber */
+
+   invokeStartElement (pctxt, "capabilityDescriptorNumber", -1);
+
+   stat = asn1PD_H245CapabilityDescriptorNumber (pctxt, &pvalue->capabilityDescriptorNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "capabilityDescriptorNumber", -1);
+
+   /* decode simultaneousCapabilities */
+
+   if (pvalue->m.simultaneousCapabilitiesPresent) {
+      invokeStartElement (pctxt, "simultaneousCapabilities", -1);
+
+      stat = asn1PD_H245CapabilityDescriptor_simultaneousCapabilities (pctxt, &pvalue->simultaneousCapabilities);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "simultaneousCapabilities", -1);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet_capabilityDescriptors               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalCapabilitySet_capabilityDescriptors (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityDescriptors* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245CapabilityDescriptor* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245CapabilityDescriptor);
+
+      stat = asn1PD_H245CapabilityDescriptor (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalCapabilitySet (OOCTXT* pctxt, H245TerminalCapabilitySet* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.multiplexCapabilityPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.capabilityTablePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.capabilityDescriptorsPresent = optbit;
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode protocolIdentifier */
+
+   invokeStartElement (pctxt, "protocolIdentifier", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->protocolIdentifier.numids, pvalue->protocolIdentifier.subid);
+
+   invokeEndElement (pctxt, "protocolIdentifier", -1);
+
+   /* decode multiplexCapability */
+
+   if (pvalue->m.multiplexCapabilityPresent) {
+      invokeStartElement (pctxt, "multiplexCapability", -1);
+
+      stat = asn1PD_H245MultiplexCapability (pctxt, &pvalue->multiplexCapability);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "multiplexCapability", -1);
+   }
+
+   /* decode capabilityTable */
+
+   if (pvalue->m.capabilityTablePresent) {
+      invokeStartElement (pctxt, "capabilityTable", -1);
+
+      stat = asn1PD_H245TerminalCapabilitySet_capabilityTable (pctxt, &pvalue->capabilityTable);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "capabilityTable", -1);
+   }
+
+   /* decode capabilityDescriptors */
+
+   if (pvalue->m.capabilityDescriptorsPresent) {
+      invokeStartElement (pctxt, "capabilityDescriptors", -1);
+
+      stat = asn1PD_H245TerminalCapabilitySet_capabilityDescriptors (pctxt, &pvalue->capabilityDescriptors);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "capabilityDescriptors", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelNumber                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245LogicalChannelNumber (OOCTXT* pctxt, H245LogicalChannelNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt16 (pctxt, pvalue, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionMode                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EncryptionMode (OOCTXT* pctxt, H245EncryptionMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* h233Encryption */
+         case 1:
+            invokeStartElement (pctxt, "h233Encryption", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "h233Encryption", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingElement                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingElement (OOCTXT* pctxt, H245RedundancyEncodingElement* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.payloadTypePresent = optbit;
+
+   /* decode dataType */
+
+   invokeStartElement (pctxt, "dataType", -1);
+
+   pvalue->dataType = ALLOC_ASN1ELEM (pctxt, H245DataType);
+
+   stat = asn1PD_H245DataType (pctxt, (H245DataType*)pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "dataType", -1);
+
+   /* decode payloadType */
+
+   if (pvalue->m.payloadTypePresent) {
+      invokeStartElement (pctxt, "payloadType", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->payloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->payloadType);
+
+      invokeEndElement (pctxt, "payloadType", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245RedundancyEncodingElement                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245RedundancyEncodingElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingElement* pvalue)
+{
+   int stat = ASN_OK;
+   H245RedundancyEncodingElement* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245RedundancyEncodingElement);
+
+         stat = asn1PD_H245RedundancyEncodingElement (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncoding_rtpRedundancyEncoding                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncoding_rtpRedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding_rtpRedundancyEncoding* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.primaryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.secondaryPresent = optbit;
+
+   /* decode primary */
+
+   if (pvalue->m.primaryPresent) {
+      invokeStartElement (pctxt, "primary", -1);
+
+      stat = asn1PD_H245RedundancyEncodingElement (pctxt, &pvalue->primary);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "primary", -1);
+   }
+
+   /* decode secondary */
+
+   if (pvalue->m.secondaryPresent) {
+      invokeStartElement (pctxt, "secondary", -1);
+
+      stat = asn1PD_H245_SeqOfH245RedundancyEncodingElement (pctxt, &pvalue->secondary);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "secondary", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncoding                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.secondaryEncodingPresent = optbit;
+
+   /* decode redundancyEncodingMethod */
+
+   invokeStartElement (pctxt, "redundancyEncodingMethod", -1);
+
+   stat = asn1PD_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "redundancyEncodingMethod", -1);
+
+   /* decode secondaryEncoding */
+
+   if (pvalue->m.secondaryEncodingPresent) {
+      invokeStartElement (pctxt, "secondaryEncoding", -1);
+
+      pvalue->secondaryEncoding = ALLOC_ASN1ELEM (pctxt, H245DataType);
+
+      stat = asn1PD_H245DataType (pctxt, (H245DataType*)pvalue->secondaryEncoding);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "secondaryEncoding", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.rtpRedundancyEncodingPresent = 1;
+
+                     invokeStartElement (pctxt, "rtpRedundancyEncoding", -1);
+
+                     stat = asn1PD_H245RedundancyEncoding_rtpRedundancyEncoding (pctxt, &pvalue->rtpRedundancyEncoding);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "rtpRedundancyEncoding", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamElement                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplePayloadStreamElement (OOCTXT* pctxt, H245MultiplePayloadStreamElement* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.payloadTypePresent = optbit;
+
+   /* decode dataType */
+
+   invokeStartElement (pctxt, "dataType", -1);
+
+   pvalue->dataType = ALLOC_ASN1ELEM (pctxt, H245DataType);
+
+   stat = asn1PD_H245DataType (pctxt, (H245DataType*)pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "dataType", -1);
+
+   /* decode payloadType */
+
+   if (pvalue->m.payloadTypePresent) {
+      invokeStartElement (pctxt, "payloadType", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->payloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->payloadType);
+
+      invokeEndElement (pctxt, "payloadType", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MultiplePayloadStreamElement                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245MultiplePayloadStreamElement (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElement* pvalue)
+{
+   int stat = ASN_OK;
+   H245MultiplePayloadStreamElement* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MultiplePayloadStreamElement);
+
+         stat = asn1PD_H245MultiplePayloadStreamElement (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStream                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplePayloadStream (OOCTXT* pctxt, H245MultiplePayloadStream* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode elements */
+
+   invokeStartElement (pctxt, "elements", -1);
+
+   stat = asn1PD_H245_SeqOfH245MultiplePayloadStreamElement (pctxt, &pvalue->elements);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "elements", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream_differentPort         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_differentPort* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.protectedPayloadTypePresent = optbit;
+
+   /* decode protectedSessionID */
+
+   invokeStartElement (pctxt, "protectedSessionID", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->protectedSessionID, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->protectedSessionID);
+
+   invokeEndElement (pctxt, "protectedSessionID", -1);
+
+   /* decode protectedPayloadType */
+
+   if (pvalue->m.protectedPayloadTypePresent) {
+      invokeStartElement (pctxt, "protectedPayloadType", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->protectedPayloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->protectedPayloadType);
+
+      invokeEndElement (pctxt, "protectedPayloadType", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream_samePort              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream_samePort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_samePort* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode protectedPayloadType */
+
+   invokeStartElement (pctxt, "protectedPayloadType", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->protectedPayloadType, 0U, 127U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->protectedPayloadType);
+
+   invokeEndElement (pctxt, "protectedPayloadType", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* differentPort */
+         case 0:
+            invokeStartElement (pctxt, "differentPort", -1);
+
+            pvalue->u.differentPort = ALLOC_ASN1ELEM (pctxt, H245FECData_rfc2733_mode_separateStream_differentPort);
+
+            stat = asn1PD_H245FECData_rfc2733_mode_separateStream_differentPort (pctxt, pvalue->u.differentPort);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "differentPort", -1);
+
+            break;
+
+         /* samePort */
+         case 1:
+            invokeStartElement (pctxt, "samePort", -1);
+
+            pvalue->u.samePort = ALLOC_ASN1ELEM (pctxt, H245FECData_rfc2733_mode_separateStream_samePort);
+
+            stat = asn1PD_H245FECData_rfc2733_mode_separateStream_samePort (pctxt, pvalue->u.samePort);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "samePort", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECData_rfc2733_mode (OOCTXT* pctxt, H245FECData_rfc2733_mode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* redundancyEncoding */
+         case 0:
+            invokeStartElement (pctxt, "redundancyEncoding", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "redundancyEncoding", -1);
+
+            break;
+
+         /* separateStream */
+         case 1:
+            invokeStartElement (pctxt, "separateStream", -1);
+
+            pvalue->u.separateStream = ALLOC_ASN1ELEM (pctxt, H245FECData_rfc2733_mode_separateStream);
+
+            stat = asn1PD_H245FECData_rfc2733_mode_separateStream (pctxt, pvalue->u.separateStream);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "separateStream", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECData_rfc2733 (OOCTXT* pctxt, H245FECData_rfc2733* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode mode */
+
+   invokeStartElement (pctxt, "mode", -1);
+
+   stat = asn1PD_H245FECData_rfc2733_mode (pctxt, &pvalue->mode);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECData (OOCTXT* pctxt, H245FECData* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* rfc2733 */
+      case 0:
+         invokeStartElement (pctxt, "rfc2733", -1);
+
+         pvalue->u.rfc2733 = ALLOC_ASN1ELEM (pctxt, H245FECData_rfc2733);
+
+         stat = asn1PD_H245FECData_rfc2733 (pctxt, pvalue->u.rfc2733);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "rfc2733", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235Media_mediaType                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H235Media_mediaType (OOCTXT* pctxt, H245H235Media_mediaType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* videoData */
+         case 1:
+            invokeStartElement (pctxt, "videoData", -1);
+
+            pvalue->u.videoData = ALLOC_ASN1ELEM (pctxt, H245VideoCapability);
+
+            stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.videoData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoData", -1);
+
+            break;
+
+         /* audioData */
+         case 2:
+            invokeStartElement (pctxt, "audioData", -1);
+
+            pvalue->u.audioData = ALLOC_ASN1ELEM (pctxt, H245AudioCapability);
+
+            stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.audioData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioData", -1);
+
+            break;
+
+         /* data */
+         case 3:
+            invokeStartElement (pctxt, "data", -1);
+
+            pvalue->u.data = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability);
+
+            stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.data);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "data", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* redundancyEncoding */
+         case 5:
+            invokeStartElement (pctxt, "redundancyEncoding", -1);
+
+            pvalue->u.redundancyEncoding = ALLOC_ASN1ELEM (pctxt, H245RedundancyEncoding);
+
+            stat = asn1PD_H245RedundancyEncoding (pctxt, pvalue->u.redundancyEncoding);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "redundancyEncoding", -1);
+
+            break;
+
+         /* multiplePayloadStream */
+         case 6:
+            invokeStartElement (pctxt, "multiplePayloadStream", -1);
+
+            pvalue->u.multiplePayloadStream = ALLOC_ASN1ELEM (pctxt, H245MultiplePayloadStream);
+
+            stat = asn1PD_H245MultiplePayloadStream (pctxt, pvalue->u.multiplePayloadStream);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplePayloadStream", -1);
+
+            break;
+
+         /* fec */
+         case 7:
+            invokeStartElement (pctxt, "fec", -1);
+
+            pvalue->u.fec = ALLOC_ASN1ELEM (pctxt, H245FECData);
+
+            stat = asn1PD_H245FECData (pctxt, pvalue->u.fec);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "fec", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235Media                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H235Media (OOCTXT* pctxt, H245H235Media* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode encryptionAuthenticationAndIntegrity */
+
+   invokeStartElement (pctxt, "encryptionAuthenticationAndIntegrity", -1);
+
+   stat = asn1PD_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "encryptionAuthenticationAndIntegrity", -1);
+
+   /* decode mediaType */
+
+   invokeStartElement (pctxt, "mediaType", -1);
+
+   stat = asn1PD_H245H235Media_mediaType (pctxt, &pvalue->mediaType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mediaType", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamParameter                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexedStreamParameter (OOCTXT* pctxt, H245MultiplexedStreamParameter* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode multiplexFormat */
+
+   invokeStartElement (pctxt, "multiplexFormat", -1);
+
+   stat = asn1PD_H245MultiplexFormat (pctxt, &pvalue->multiplexFormat);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexFormat", -1);
+
+   /* decode controlOnMuxStream */
+
+   invokeStartElement (pctxt, "controlOnMuxStream", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->controlOnMuxStream);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->controlOnMuxStream);
+
+   invokeEndElement (pctxt, "controlOnMuxStream", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataType                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataType (OOCTXT* pctxt, H245DataType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* nullData */
+         case 1:
+            invokeStartElement (pctxt, "nullData", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nullData", -1);
+
+            break;
+
+         /* videoData */
+         case 2:
+            invokeStartElement (pctxt, "videoData", -1);
+
+            pvalue->u.videoData = ALLOC_ASN1ELEM (pctxt, H245VideoCapability);
+
+            stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.videoData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoData", -1);
+
+            break;
+
+         /* audioData */
+         case 3:
+            invokeStartElement (pctxt, "audioData", -1);
+
+            pvalue->u.audioData = ALLOC_ASN1ELEM (pctxt, H245AudioCapability);
+
+            stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.audioData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioData", -1);
+
+            break;
+
+         /* data */
+         case 4:
+            invokeStartElement (pctxt, "data", -1);
+
+            pvalue->u.data = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability);
+
+            stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.data);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "data", -1);
+
+            break;
+
+         /* encryptionData */
+         case 5:
+            invokeStartElement (pctxt, "encryptionData", -1);
+
+            pvalue->u.encryptionData = ALLOC_ASN1ELEM (pctxt, H245EncryptionMode);
+
+            stat = asn1PD_H245EncryptionMode (pctxt, pvalue->u.encryptionData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "encryptionData", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* h235Control */
+         case 7:
+            invokeStartElement (pctxt, "h235Control", -1);
+
+            pvalue->u.h235Control = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.h235Control);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h235Control", -1);
+
+            break;
+
+         /* h235Media */
+         case 8:
+            invokeStartElement (pctxt, "h235Media", -1);
+
+            pvalue->u.h235Media = ALLOC_ASN1ELEM (pctxt, H245H235Media);
+
+            stat = asn1PD_H245H235Media (pctxt, pvalue->u.h235Media);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h235Media", -1);
+
+            break;
+
+         /* multiplexedStream */
+         case 9:
+            invokeStartElement (pctxt, "multiplexedStream", -1);
+
+            pvalue->u.multiplexedStream = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamParameter);
+
+            stat = asn1PD_H245MultiplexedStreamParameter (pctxt, pvalue->u.multiplexedStream);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplexedStream", -1);
+
+            break;
+
+         /* redundancyEncoding */
+         case 10:
+            invokeStartElement (pctxt, "redundancyEncoding", -1);
+
+            pvalue->u.redundancyEncoding = ALLOC_ASN1ELEM (pctxt, H245RedundancyEncoding);
+
+            stat = asn1PD_H245RedundancyEncoding (pctxt, pvalue->u.redundancyEncoding);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "redundancyEncoding", -1);
+
+            break;
+
+         /* multiplePayloadStream */
+         case 11:
+            invokeStartElement (pctxt, "multiplePayloadStream", -1);
+
+            pvalue->u.multiplePayloadStream = ALLOC_ASN1ELEM (pctxt, H245MultiplePayloadStream);
+
+            stat = asn1PD_H245MultiplePayloadStream (pctxt, pvalue->u.multiplePayloadStream);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplePayloadStream", -1);
+
+            break;
+
+         /* fec */
+         case 12:
+            invokeStartElement (pctxt, "fec", -1);
+
+            pvalue->u.fec = ALLOC_ASN1ELEM (pctxt, H245FECData);
+
+            stat = asn1PD_H245FECData (pctxt, pvalue->u.fec);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "fec", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H222LogicalChannelParameters                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H222LogicalChannelParameters (OOCTXT* pctxt, H245H222LogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.pcr_pidPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.programDescriptorsPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.streamDescriptorsPresent = optbit;
+
+   /* decode resourceID */
+
+   invokeStartElement (pctxt, "resourceID", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->resourceID, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->resourceID);
+
+   invokeEndElement (pctxt, "resourceID", -1);
+
+   /* decode subChannelID */
+
+   invokeStartElement (pctxt, "subChannelID", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->subChannelID, 0U, 8191U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->subChannelID);
+
+   invokeEndElement (pctxt, "subChannelID", -1);
+
+   /* decode pcr_pid */
+
+   if (pvalue->m.pcr_pidPresent) {
+      invokeStartElement (pctxt, "pcr_pid", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->pcr_pid, 0U, 8191U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->pcr_pid);
+
+      invokeEndElement (pctxt, "pcr_pid", -1);
+   }
+
+   /* decode programDescriptors */
+
+   if (pvalue->m.programDescriptorsPresent) {
+      invokeStartElement (pctxt, "programDescriptors", -1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->programDescriptors);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->programDescriptors.numocts, pvalue->programDescriptors.data);
+
+      invokeEndElement (pctxt, "programDescriptors", -1);
+   }
+
+   /* decode streamDescriptors */
+
+   if (pvalue->m.streamDescriptorsPresent) {
+      invokeStartElement (pctxt, "streamDescriptors", -1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->streamDescriptors);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->streamDescriptors.numocts, pvalue->streamDescriptors.data);
+
+      invokeEndElement (pctxt, "streamDescriptors", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters_adaptationLayerType_al3      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223LogicalChannelParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode controlFieldOctets */
+
+   invokeStartElement (pctxt, "controlFieldOctets", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->controlFieldOctets, 0U, 2U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->controlFieldOctets);
+
+   invokeEndElement (pctxt, "controlFieldOctets", -1);
+
+   /* decode sendBufferSize */
+
+   invokeStartElement (pctxt, "sendBufferSize", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->sendBufferSize, 0U, 16777215U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sendBufferSize);
+
+   invokeEndElement (pctxt, "sendBufferSize", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_transferMode                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL1MParameters_transferMode (OOCTXT* pctxt, H245H223AL1MParameters_transferMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* framed */
+         case 0:
+            invokeStartElement (pctxt, "framed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "framed", -1);
+
+            break;
+
+         /* unframed */
+         case 1:
+            invokeStartElement (pctxt, "unframed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unframed", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_headerFEC                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL1MParameters_headerFEC (OOCTXT* pctxt, H245H223AL1MParameters_headerFEC* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* sebch16_7 */
+         case 0:
+            invokeStartElement (pctxt, "sebch16_7", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "sebch16_7", -1);
+
+            break;
+
+         /* golay24_12 */
+         case 1:
+            invokeStartElement (pctxt, "golay24_12", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "golay24_12", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_crcLength                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL1MParameters_crcLength (OOCTXT* pctxt, H245H223AL1MParameters_crcLength* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* crc4bit */
+         case 0:
+            invokeStartElement (pctxt, "crc4bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc4bit", -1);
+
+            break;
+
+         /* crc12bit */
+         case 1:
+            invokeStartElement (pctxt, "crc12bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc12bit", -1);
+
+            break;
+
+         /* crc20bit */
+         case 2:
+            invokeStartElement (pctxt, "crc20bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc20bit", -1);
+
+            break;
+
+         /* crc28bit */
+         case 3:
+            invokeStartElement (pctxt, "crc28bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc28bit", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* crc8bit */
+         case 5:
+            invokeStartElement (pctxt, "crc8bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc8bit", -1);
+
+            break;
+
+         /* crc16bit */
+         case 6:
+            invokeStartElement (pctxt, "crc16bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc16bit", -1);
+
+            break;
+
+         /* crc32bit */
+         case 7:
+            invokeStartElement (pctxt, "crc32bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc32bit", -1);
+
+            break;
+
+         /* crcNotUsed */
+         case 8:
+            invokeStartElement (pctxt, "crcNotUsed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crcNotUsed", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AnnexCArqParameters_numberOfRetransmissions           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AnnexCArqParameters_numberOfRetransmissions (OOCTXT* pctxt, H245H223AnnexCArqParameters_numberOfRetransmissions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* finite */
+         case 0:
+            invokeStartElement (pctxt, "finite", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.finite, 0U, 16U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.finite);
+
+            invokeEndElement (pctxt, "finite", -1);
+
+            break;
+
+         /* infinite */
+         case 1:
+            invokeStartElement (pctxt, "infinite", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "infinite", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AnnexCArqParameters                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AnnexCArqParameters (OOCTXT* pctxt, H245H223AnnexCArqParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode numberOfRetransmissions */
+
+   invokeStartElement (pctxt, "numberOfRetransmissions", -1);
+
+   stat = asn1PD_H245H223AnnexCArqParameters_numberOfRetransmissions (pctxt, &pvalue->numberOfRetransmissions);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "numberOfRetransmissions", -1);
+
+   /* decode sendBufferSize */
+
+   invokeStartElement (pctxt, "sendBufferSize", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->sendBufferSize, 0U, 16777215U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sendBufferSize);
+
+   invokeEndElement (pctxt, "sendBufferSize", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_arqType                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL1MParameters_arqType (OOCTXT* pctxt, H245H223AL1MParameters_arqType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* noArq */
+         case 0:
+            invokeStartElement (pctxt, "noArq", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noArq", -1);
+
+            break;
+
+         /* typeIArq */
+         case 1:
+            invokeStartElement (pctxt, "typeIArq", -1);
+
+            pvalue->u.typeIArq = ALLOC_ASN1ELEM (pctxt, H245H223AnnexCArqParameters);
+
+            stat = asn1PD_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIArq);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "typeIArq", -1);
+
+            break;
+
+         /* typeIIArq */
+         case 2:
+            invokeStartElement (pctxt, "typeIIArq", -1);
+
+            pvalue->u.typeIIArq = ALLOC_ASN1ELEM (pctxt, H245H223AnnexCArqParameters);
+
+            stat = asn1PD_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIIArq);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "typeIIArq", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL1MParameters (OOCTXT* pctxt, H245H223AL1MParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode transferMode */
+
+   invokeStartElement (pctxt, "transferMode", -1);
+
+   stat = asn1PD_H245H223AL1MParameters_transferMode (pctxt, &pvalue->transferMode);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "transferMode", -1);
+
+   /* decode headerFEC */
+
+   invokeStartElement (pctxt, "headerFEC", -1);
+
+   stat = asn1PD_H245H223AL1MParameters_headerFEC (pctxt, &pvalue->headerFEC);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "headerFEC", -1);
+
+   /* decode crcLength */
+
+   invokeStartElement (pctxt, "crcLength", -1);
+
+   stat = asn1PD_H245H223AL1MParameters_crcLength (pctxt, &pvalue->crcLength);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "crcLength", -1);
+
+   /* decode rcpcCodeRate */
+
+   invokeStartElement (pctxt, "rcpcCodeRate", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->rcpcCodeRate, 8U, 32U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->rcpcCodeRate);
+
+   invokeEndElement (pctxt, "rcpcCodeRate", -1);
+
+   /* decode arqType */
+
+   invokeStartElement (pctxt, "arqType", -1);
+
+   stat = asn1PD_H245H223AL1MParameters_arqType (pctxt, &pvalue->arqType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "arqType", -1);
+
+   /* decode alpduInterleaving */
+
+   invokeStartElement (pctxt, "alpduInterleaving", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->alpduInterleaving);
+
+   invokeEndElement (pctxt, "alpduInterleaving", -1);
+
+   /* decode alsduSplitting */
+
+   invokeStartElement (pctxt, "alsduSplitting", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->alsduSplitting);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->alsduSplitting);
+
+   invokeEndElement (pctxt, "alsduSplitting", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.rsCodeCorrectionPresent = 1;
+
+                     invokeStartElement (pctxt, "rsCodeCorrection", -1);
+
+                     stat = decodeConsUInt8 (pctxt, &pvalue->rsCodeCorrection, 0U, 127U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->rsCodeCorrection);
+
+                     invokeEndElement (pctxt, "rsCodeCorrection", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL2MParameters_headerFEC                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL2MParameters_headerFEC (OOCTXT* pctxt, H245H223AL2MParameters_headerFEC* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* sebch16_5 */
+         case 0:
+            invokeStartElement (pctxt, "sebch16_5", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "sebch16_5", -1);
+
+            break;
+
+         /* golay24_12 */
+         case 1:
+            invokeStartElement (pctxt, "golay24_12", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "golay24_12", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL2MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL2MParameters (OOCTXT* pctxt, H245H223AL2MParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode headerFEC */
+
+   invokeStartElement (pctxt, "headerFEC", -1);
+
+   stat = asn1PD_H245H223AL2MParameters_headerFEC (pctxt, &pvalue->headerFEC);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "headerFEC", -1);
+
+   /* decode alpduInterleaving */
+
+   invokeStartElement (pctxt, "alpduInterleaving", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->alpduInterleaving);
+
+   invokeEndElement (pctxt, "alpduInterleaving", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_headerFormat                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL3MParameters_headerFormat (OOCTXT* pctxt, H245H223AL3MParameters_headerFormat* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* sebch16_7 */
+         case 0:
+            invokeStartElement (pctxt, "sebch16_7", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "sebch16_7", -1);
+
+            break;
+
+         /* golay24_12 */
+         case 1:
+            invokeStartElement (pctxt, "golay24_12", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "golay24_12", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_crcLength                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL3MParameters_crcLength (OOCTXT* pctxt, H245H223AL3MParameters_crcLength* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* crc4bit */
+         case 0:
+            invokeStartElement (pctxt, "crc4bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc4bit", -1);
+
+            break;
+
+         /* crc12bit */
+         case 1:
+            invokeStartElement (pctxt, "crc12bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc12bit", -1);
+
+            break;
+
+         /* crc20bit */
+         case 2:
+            invokeStartElement (pctxt, "crc20bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc20bit", -1);
+
+            break;
+
+         /* crc28bit */
+         case 3:
+            invokeStartElement (pctxt, "crc28bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc28bit", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* crc8bit */
+         case 5:
+            invokeStartElement (pctxt, "crc8bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc8bit", -1);
+
+            break;
+
+         /* crc16bit */
+         case 6:
+            invokeStartElement (pctxt, "crc16bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc16bit", -1);
+
+            break;
+
+         /* crc32bit */
+         case 7:
+            invokeStartElement (pctxt, "crc32bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc32bit", -1);
+
+            break;
+
+         /* crcNotUsed */
+         case 8:
+            invokeStartElement (pctxt, "crcNotUsed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crcNotUsed", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_arqType                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL3MParameters_arqType (OOCTXT* pctxt, H245H223AL3MParameters_arqType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* noArq */
+         case 0:
+            invokeStartElement (pctxt, "noArq", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noArq", -1);
+
+            break;
+
+         /* typeIArq */
+         case 1:
+            invokeStartElement (pctxt, "typeIArq", -1);
+
+            pvalue->u.typeIArq = ALLOC_ASN1ELEM (pctxt, H245H223AnnexCArqParameters);
+
+            stat = asn1PD_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIArq);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "typeIArq", -1);
+
+            break;
+
+         /* typeIIArq */
+         case 2:
+            invokeStartElement (pctxt, "typeIIArq", -1);
+
+            pvalue->u.typeIIArq = ALLOC_ASN1ELEM (pctxt, H245H223AnnexCArqParameters);
+
+            stat = asn1PD_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIIArq);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "typeIIArq", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223AL3MParameters (OOCTXT* pctxt, H245H223AL3MParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode headerFormat */
+
+   invokeStartElement (pctxt, "headerFormat", -1);
+
+   stat = asn1PD_H245H223AL3MParameters_headerFormat (pctxt, &pvalue->headerFormat);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "headerFormat", -1);
+
+   /* decode crcLength */
+
+   invokeStartElement (pctxt, "crcLength", -1);
+
+   stat = asn1PD_H245H223AL3MParameters_crcLength (pctxt, &pvalue->crcLength);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "crcLength", -1);
+
+   /* decode rcpcCodeRate */
+
+   invokeStartElement (pctxt, "rcpcCodeRate", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->rcpcCodeRate, 8U, 32U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->rcpcCodeRate);
+
+   invokeEndElement (pctxt, "rcpcCodeRate", -1);
+
+   /* decode arqType */
+
+   invokeStartElement (pctxt, "arqType", -1);
+
+   stat = asn1PD_H245H223AL3MParameters_arqType (pctxt, &pvalue->arqType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "arqType", -1);
+
+   /* decode alpduInterleaving */
+
+   invokeStartElement (pctxt, "alpduInterleaving", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->alpduInterleaving);
+
+   invokeEndElement (pctxt, "alpduInterleaving", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.rsCodeCorrectionPresent = 1;
+
+                     invokeStartElement (pctxt, "rsCodeCorrection", -1);
+
+                     stat = decodeConsUInt8 (pctxt, &pvalue->rsCodeCorrection, 0U, 127U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->rsCodeCorrection);
+
+                     invokeEndElement (pctxt, "rsCodeCorrection", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters_adaptationLayerType          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223LogicalChannelParameters_adaptationLayerType (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* al1Framed */
+         case 1:
+            invokeStartElement (pctxt, "al1Framed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "al1Framed", -1);
+
+            break;
+
+         /* al1NotFramed */
+         case 2:
+            invokeStartElement (pctxt, "al1NotFramed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "al1NotFramed", -1);
+
+            break;
+
+         /* al2WithoutSequenceNumbers */
+         case 3:
+            invokeStartElement (pctxt, "al2WithoutSequenceNumbers", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "al2WithoutSequenceNumbers", -1);
+
+            break;
+
+         /* al2WithSequenceNumbers */
+         case 4:
+            invokeStartElement (pctxt, "al2WithSequenceNumbers", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "al2WithSequenceNumbers", -1);
+
+            break;
+
+         /* al3 */
+         case 5:
+            invokeStartElement (pctxt, "al3", -1);
+
+            pvalue->u.al3 = ALLOC_ASN1ELEM (pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3);
+
+            stat = asn1PD_H245H223LogicalChannelParameters_adaptationLayerType_al3 (pctxt, pvalue->u.al3);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "al3", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* al1M */
+         case 7:
+            invokeStartElement (pctxt, "al1M", -1);
+
+            pvalue->u.al1M = ALLOC_ASN1ELEM (pctxt, H245H223AL1MParameters);
+
+            stat = asn1PD_H245H223AL1MParameters (pctxt, pvalue->u.al1M);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "al1M", -1);
+
+            break;
+
+         /* al2M */
+         case 8:
+            invokeStartElement (pctxt, "al2M", -1);
+
+            pvalue->u.al2M = ALLOC_ASN1ELEM (pctxt, H245H223AL2MParameters);
+
+            stat = asn1PD_H245H223AL2MParameters (pctxt, pvalue->u.al2M);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "al2M", -1);
+
+            break;
+
+         /* al3M */
+         case 9:
+            invokeStartElement (pctxt, "al3M", -1);
+
+            pvalue->u.al3M = ALLOC_ASN1ELEM (pctxt, H245H223AL3MParameters);
+
+            stat = asn1PD_H245H223AL3MParameters (pctxt, pvalue->u.al3M);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "al3M", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223LogicalChannelParameters (OOCTXT* pctxt, H245H223LogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode adaptationLayerType */
+
+   invokeStartElement (pctxt, "adaptationLayerType", -1);
+
+   stat = asn1PD_H245H223LogicalChannelParameters_adaptationLayerType (pctxt, &pvalue->adaptationLayerType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "adaptationLayerType", -1);
+
+   /* decode segmentableFlag */
+
+   invokeStartElement (pctxt, "segmentableFlag", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->segmentableFlag);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->segmentableFlag);
+
+   invokeEndElement (pctxt, "segmentableFlag", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CRCLength                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CRCLength (OOCTXT* pctxt, H245CRCLength* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* crc8bit */
+         case 0:
+            invokeStartElement (pctxt, "crc8bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc8bit", -1);
+
+            break;
+
+         /* crc16bit */
+         case 1:
+            invokeStartElement (pctxt, "crc16bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc16bit", -1);
+
+            break;
+
+         /* crc32bit */
+         case 2:
+            invokeStartElement (pctxt, "crc32bit", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "crc32bit", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76HDLCParameters                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V76HDLCParameters (OOCTXT* pctxt, H245V76HDLCParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode crcLength */
+
+   invokeStartElement (pctxt, "crcLength", -1);
+
+   stat = asn1PD_H245CRCLength (pctxt, &pvalue->crcLength);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "crcLength", -1);
+
+   /* decode n401 */
+
+   invokeStartElement (pctxt, "n401", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->n401, 1U, 4095U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->n401);
+
+   invokeEndElement (pctxt, "n401", -1);
+
+   /* decode loopbackTestProcedure */
+
+   invokeStartElement (pctxt, "loopbackTestProcedure", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->loopbackTestProcedure);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->loopbackTestProcedure);
+
+   invokeEndElement (pctxt, "loopbackTestProcedure", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_suspendResume                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters_suspendResume (OOCTXT* pctxt, H245V76LogicalChannelParameters_suspendResume* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* noSuspendResume */
+         case 0:
+            invokeStartElement (pctxt, "noSuspendResume", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noSuspendResume", -1);
+
+            break;
+
+         /* suspendResumewAddress */
+         case 1:
+            invokeStartElement (pctxt, "suspendResumewAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "suspendResumewAddress", -1);
+
+            break;
+
+         /* suspendResumewoAddress */
+         case 2:
+            invokeStartElement (pctxt, "suspendResumewoAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "suspendResumewoAddress", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode_eRM_recovery             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters_mode_eRM_recovery (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM_recovery* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* rej */
+         case 0:
+            invokeStartElement (pctxt, "rej", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "rej", -1);
+
+            break;
+
+         /* sREJ */
+         case 1:
+            invokeStartElement (pctxt, "sREJ", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "sREJ", -1);
+
+            break;
+
+         /* mSREJ */
+         case 2:
+            invokeStartElement (pctxt, "mSREJ", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "mSREJ", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode_eRM                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters_mode_eRM (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode windowSize */
+
+   invokeStartElement (pctxt, "windowSize", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->windowSize, 1U, 127U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->windowSize);
+
+   invokeEndElement (pctxt, "windowSize", -1);
+
+   /* decode recovery */
+
+   invokeStartElement (pctxt, "recovery", -1);
+
+   stat = asn1PD_H245V76LogicalChannelParameters_mode_eRM_recovery (pctxt, &pvalue->recovery);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "recovery", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters_mode (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* eRM */
+         case 0:
+            invokeStartElement (pctxt, "eRM", -1);
+
+            pvalue->u.eRM = ALLOC_ASN1ELEM (pctxt, H245V76LogicalChannelParameters_mode_eRM);
+
+            stat = asn1PD_H245V76LogicalChannelParameters_mode_eRM (pctxt, pvalue->u.eRM);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "eRM", -1);
+
+            break;
+
+         /* uNERM */
+         case 1:
+            invokeStartElement (pctxt, "uNERM", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "uNERM", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V75Parameters                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V75Parameters (OOCTXT* pctxt, H245V75Parameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode audioHeaderPresent */
+
+   invokeStartElement (pctxt, "audioHeaderPresent", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->audioHeaderPresent);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->audioHeaderPresent);
+
+   invokeEndElement (pctxt, "audioHeaderPresent", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V76LogicalChannelParameters (OOCTXT* pctxt, H245V76LogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode hdlcParameters */
+
+   invokeStartElement (pctxt, "hdlcParameters", -1);
+
+   stat = asn1PD_H245V76HDLCParameters (pctxt, &pvalue->hdlcParameters);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "hdlcParameters", -1);
+
+   /* decode suspendResume */
+
+   invokeStartElement (pctxt, "suspendResume", -1);
+
+   stat = asn1PD_H245V76LogicalChannelParameters_suspendResume (pctxt, &pvalue->suspendResume);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "suspendResume", -1);
+
+   /* decode uIH */
+
+   invokeStartElement (pctxt, "uIH", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->uIH);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->uIH);
+
+   invokeEndElement (pctxt, "uIH", -1);
+
+   /* decode mode */
+
+   invokeStartElement (pctxt, "mode", -1);
+
+   stat = asn1PD_H245V76LogicalChannelParameters_mode (pctxt, &pvalue->mode);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mode", -1);
+
+   /* decode v75Parameters */
+
+   invokeStartElement (pctxt, "v75Parameters", -1);
+
+   stat = asn1PD_H245V75Parameters (pctxt, &pvalue->v75Parameters);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "v75Parameters", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPAddress_network                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPAddress_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPAddress                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPAddress (OOCTXT* pctxt, H245UnicastAddress_iPAddress* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode network */
+
+   invokeStartElement (pctxt, "network", -1);
+
+   stat = asn1PD_H245UnicastAddress_iPAddress_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "network", -1);
+
+   /* decode tsapIdentifier */
+
+   invokeStartElement (pctxt, "tsapIdentifier", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->tsapIdentifier);
+
+   invokeEndElement (pctxt, "tsapIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_node                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPXAddress_node (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_node* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_netnum                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPXAddress_netnum (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_netnum* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_tsapIdentifier                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPXAddress_tsapIdentifier (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_tsapIdentifier* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPXAddress (OOCTXT* pctxt, H245UnicastAddress_iPXAddress* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode node */
+
+   invokeStartElement (pctxt, "node", -1);
+
+   stat = asn1PD_H245UnicastAddress_iPXAddress_node (pctxt, &pvalue->node);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "node", -1);
+
+   /* decode netnum */
+
+   invokeStartElement (pctxt, "netnum", -1);
+
+   stat = asn1PD_H245UnicastAddress_iPXAddress_netnum (pctxt, &pvalue->netnum);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "netnum", -1);
+
+   /* decode tsapIdentifier */
+
+   invokeStartElement (pctxt, "tsapIdentifier", -1);
+
+   stat = asn1PD_H245UnicastAddress_iPXAddress_tsapIdentifier (pctxt, &pvalue->tsapIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "tsapIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iP6Address_network                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iP6Address_network (OOCTXT* pctxt, H245UnicastAddress_iP6Address_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iP6Address                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iP6Address (OOCTXT* pctxt, H245UnicastAddress_iP6Address* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode network */
+
+   invokeStartElement (pctxt, "network", -1);
+
+   stat = asn1PD_H245UnicastAddress_iP6Address_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "network", -1);
+
+   /* decode tsapIdentifier */
+
+   invokeStartElement (pctxt, "tsapIdentifier", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->tsapIdentifier);
+
+   invokeEndElement (pctxt, "tsapIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_netBios                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_netBios (OOCTXT* pctxt, H245UnicastAddress_netBios* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_routing               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_routing (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_routing* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* strict */
+      case 0:
+         invokeStartElement (pctxt, "strict", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "strict", -1);
+
+         break;
+
+      /* loose */
+      case 1:
+         invokeStartElement (pctxt, "loose", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "loose", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_network               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_route_element         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_route_element* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245UnicastAddress_iPSourceRouteAddress_route_elem  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, H245UnicastAddress_iPSourceRouteAddress_route_element);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245UnicastAddress_iPSourceRouteAddress_route_element (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode routing */
+
+   invokeStartElement (pctxt, "routing", -1);
+
+   stat = asn1PD_H245UnicastAddress_iPSourceRouteAddress_routing (pctxt, &pvalue->routing);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "routing", -1);
+
+   /* decode network */
+
+   invokeStartElement (pctxt, "network", -1);
+
+   stat = asn1PD_H245UnicastAddress_iPSourceRouteAddress_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "network", -1);
+
+   /* decode tsapIdentifier */
+
+   invokeStartElement (pctxt, "tsapIdentifier", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->tsapIdentifier);
+
+   invokeEndElement (pctxt, "tsapIdentifier", -1);
+
+   /* decode route */
+
+   invokeStartElement (pctxt, "route", -1);
+
+   stat = asn1PD_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (pctxt, &pvalue->route);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "route", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_nsap                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress_nsap (OOCTXT* pctxt, H245UnicastAddress_nsap* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UnicastAddress (OOCTXT* pctxt, H245UnicastAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* iPAddress */
+         case 0:
+            invokeStartElement (pctxt, "iPAddress", -1);
+
+            pvalue->u.iPAddress = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_iPAddress);
+
+            stat = asn1PD_H245UnicastAddress_iPAddress (pctxt, pvalue->u.iPAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "iPAddress", -1);
+
+            break;
+
+         /* iPXAddress */
+         case 1:
+            invokeStartElement (pctxt, "iPXAddress", -1);
+
+            pvalue->u.iPXAddress = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_iPXAddress);
+
+            stat = asn1PD_H245UnicastAddress_iPXAddress (pctxt, pvalue->u.iPXAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "iPXAddress", -1);
+
+            break;
+
+         /* iP6Address */
+         case 2:
+            invokeStartElement (pctxt, "iP6Address", -1);
+
+            pvalue->u.iP6Address = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_iP6Address);
+
+            stat = asn1PD_H245UnicastAddress_iP6Address (pctxt, pvalue->u.iP6Address);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "iP6Address", -1);
+
+            break;
+
+         /* netBios */
+         case 3:
+            invokeStartElement (pctxt, "netBios", -1);
+
+            pvalue->u.netBios = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_netBios);
+
+            stat = asn1PD_H245UnicastAddress_netBios (pctxt, pvalue->u.netBios);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "netBios", -1);
+
+            break;
+
+         /* iPSourceRouteAddress */
+         case 4:
+            invokeStartElement (pctxt, "iPSourceRouteAddress", -1);
+
+            pvalue->u.iPSourceRouteAddress = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_iPSourceRouteAddress);
+
+            stat = asn1PD_H245UnicastAddress_iPSourceRouteAddress (pctxt, pvalue->u.iPSourceRouteAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "iPSourceRouteAddress", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* nsap */
+         case 6:
+            invokeStartElement (pctxt, "nsap", -1);
+
+            pvalue->u.nsap = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_nsap);
+
+            stat = asn1PD_H245UnicastAddress_nsap (pctxt, pvalue->u.nsap);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nsap", -1);
+
+            break;
+
+         /* nonStandardAddress */
+         case 7:
+            invokeStartElement (pctxt, "nonStandardAddress", -1);
+
+            pvalue->u.nonStandardAddress = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandardAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandardAddress", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iPAddress_network                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MulticastAddress_iPAddress_network (OOCTXT* pctxt, H245MulticastAddress_iPAddress_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iPAddress                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MulticastAddress_iPAddress (OOCTXT* pctxt, H245MulticastAddress_iPAddress* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode network */
+
+   invokeStartElement (pctxt, "network", -1);
+
+   stat = asn1PD_H245MulticastAddress_iPAddress_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "network", -1);
+
+   /* decode tsapIdentifier */
+
+   invokeStartElement (pctxt, "tsapIdentifier", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->tsapIdentifier);
+
+   invokeEndElement (pctxt, "tsapIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iP6Address_network                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MulticastAddress_iP6Address_network (OOCTXT* pctxt, H245MulticastAddress_iP6Address_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iP6Address                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MulticastAddress_iP6Address (OOCTXT* pctxt, H245MulticastAddress_iP6Address* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode network */
+
+   invokeStartElement (pctxt, "network", -1);
+
+   stat = asn1PD_H245MulticastAddress_iP6Address_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "network", -1);
+
+   /* decode tsapIdentifier */
+
+   invokeStartElement (pctxt, "tsapIdentifier", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->tsapIdentifier);
+
+   invokeEndElement (pctxt, "tsapIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_nsap                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MulticastAddress_nsap (OOCTXT* pctxt, H245MulticastAddress_nsap* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MulticastAddress (OOCTXT* pctxt, H245MulticastAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* iPAddress */
+         case 0:
+            invokeStartElement (pctxt, "iPAddress", -1);
+
+            pvalue->u.iPAddress = ALLOC_ASN1ELEM (pctxt, H245MulticastAddress_iPAddress);
+
+            stat = asn1PD_H245MulticastAddress_iPAddress (pctxt, pvalue->u.iPAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "iPAddress", -1);
+
+            break;
+
+         /* iP6Address */
+         case 1:
+            invokeStartElement (pctxt, "iP6Address", -1);
+
+            pvalue->u.iP6Address = ALLOC_ASN1ELEM (pctxt, H245MulticastAddress_iP6Address);
+
+            stat = asn1PD_H245MulticastAddress_iP6Address (pctxt, pvalue->u.iP6Address);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "iP6Address", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* nsap */
+         case 3:
+            invokeStartElement (pctxt, "nsap", -1);
+
+            pvalue->u.nsap = ALLOC_ASN1ELEM (pctxt, H245MulticastAddress_nsap);
+
+            stat = asn1PD_H245MulticastAddress_nsap (pctxt, pvalue->u.nsap);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nsap", -1);
+
+            break;
+
+         /* nonStandardAddress */
+         case 4:
+            invokeStartElement (pctxt, "nonStandardAddress", -1);
+
+            pvalue->u.nonStandardAddress = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandardAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandardAddress", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TransportAddress (OOCTXT* pctxt, H245TransportAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unicastAddress */
+         case 0:
+            invokeStartElement (pctxt, "unicastAddress", -1);
+
+            pvalue->u.unicastAddress = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress);
+
+            stat = asn1PD_H245UnicastAddress (pctxt, pvalue->u.unicastAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "unicastAddress", -1);
+
+            break;
+
+         /* multicastAddress */
+         case 1:
+            invokeStartElement (pctxt, "multicastAddress", -1);
+
+            pvalue->u.multicastAddress = ALLOC_ASN1ELEM (pctxt, H245MulticastAddress);
+
+            stat = asn1PD_H245MulticastAddress (pctxt, pvalue->u.multicastAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multicastAddress", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  McuNumber                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245McuNumber (OOCTXT* pctxt, H245McuNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt8 (pctxt, pvalue, 0U, 192U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalNumber                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalNumber (OOCTXT* pctxt, H245TerminalNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt8 (pctxt, pvalue, 0U, 192U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalLabel                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalLabel (OOCTXT* pctxt, H245TerminalLabel* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode mcuNumber */
+
+   invokeStartElement (pctxt, "mcuNumber", -1);
+
+   stat = asn1PD_H245McuNumber (pctxt, &pvalue->mcuNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mcuNumber", -1);
+
+   /* decode terminalNumber */
+
+   invokeStartElement (pctxt, "terminalNumber", -1);
+
+   stat = asn1PD_H245TerminalNumber (pctxt, &pvalue->terminalNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelParameters_mediaPacketization          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H2250LogicalChannelParameters_mediaPacketization (OOCTXT* pctxt, H245H2250LogicalChannelParameters_mediaPacketization* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* h261aVideoPacketization */
+         case 0:
+            invokeStartElement (pctxt, "h261aVideoPacketization", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "h261aVideoPacketization", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* rtpPayloadType */
+         case 2:
+            invokeStartElement (pctxt, "rtpPayloadType", -1);
+
+            pvalue->u.rtpPayloadType = ALLOC_ASN1ELEM (pctxt, H245RTPPayloadType);
+
+            stat = asn1PD_H245RTPPayloadType (pctxt, pvalue->u.rtpPayloadType);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "rtpPayloadType", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelParameters                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H2250LogicalChannelParameters (OOCTXT* pctxt, H245H2250LogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.associatedSessionIDPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaChannelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaGuaranteedDeliveryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaControlChannelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaControlGuaranteedDeliveryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.silenceSuppressionPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.destinationPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.dynamicRTPPayloadTypePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaPacketizationPresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   /* decode sessionID */
+
+   invokeStartElement (pctxt, "sessionID", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sessionID, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sessionID);
+
+   invokeEndElement (pctxt, "sessionID", -1);
+
+   /* decode associatedSessionID */
+
+   if (pvalue->m.associatedSessionIDPresent) {
+      invokeStartElement (pctxt, "associatedSessionID", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->associatedSessionID, 1U, 255U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->associatedSessionID);
+
+      invokeEndElement (pctxt, "associatedSessionID", -1);
+   }
+
+   /* decode mediaChannel */
+
+   if (pvalue->m.mediaChannelPresent) {
+      invokeStartElement (pctxt, "mediaChannel", -1);
+
+      stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaChannel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaChannel", -1);
+   }
+
+   /* decode mediaGuaranteedDelivery */
+
+   if (pvalue->m.mediaGuaranteedDeliveryPresent) {
+      invokeStartElement (pctxt, "mediaGuaranteedDelivery", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->mediaGuaranteedDelivery);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->mediaGuaranteedDelivery);
+
+      invokeEndElement (pctxt, "mediaGuaranteedDelivery", -1);
+   }
+
+   /* decode mediaControlChannel */
+
+   if (pvalue->m.mediaControlChannelPresent) {
+      invokeStartElement (pctxt, "mediaControlChannel", -1);
+
+      stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaControlChannel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaControlChannel", -1);
+   }
+
+   /* decode mediaControlGuaranteedDelivery */
+
+   if (pvalue->m.mediaControlGuaranteedDeliveryPresent) {
+      invokeStartElement (pctxt, "mediaControlGuaranteedDelivery", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->mediaControlGuaranteedDelivery);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->mediaControlGuaranteedDelivery);
+
+      invokeEndElement (pctxt, "mediaControlGuaranteedDelivery", -1);
+   }
+
+   /* decode silenceSuppression */
+
+   if (pvalue->m.silenceSuppressionPresent) {
+      invokeStartElement (pctxt, "silenceSuppression", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->silenceSuppression);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->silenceSuppression);
+
+      invokeEndElement (pctxt, "silenceSuppression", -1);
+   }
+
+   /* decode destination */
+
+   if (pvalue->m.destinationPresent) {
+      invokeStartElement (pctxt, "destination", -1);
+
+      stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->destination);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "destination", -1);
+   }
+
+   /* decode dynamicRTPPayloadType */
+
+   if (pvalue->m.dynamicRTPPayloadTypePresent) {
+      invokeStartElement (pctxt, "dynamicRTPPayloadType", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->dynamicRTPPayloadType, 96U, 127U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->dynamicRTPPayloadType);
+
+      invokeEndElement (pctxt, "dynamicRTPPayloadType", -1);
+   }
+
+   /* decode mediaPacketization */
+
+   if (pvalue->m.mediaPacketizationPresent) {
+      invokeStartElement (pctxt, "mediaPacketization", -1);
+
+      stat = asn1PD_H245H2250LogicalChannelParameters_mediaPacketization (pctxt, &pvalue->mediaPacketization);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaPacketization", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 3 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.transportCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "transportCapability", -1);
+
+                     stat = asn1PD_H245TransportCapability (pctxt, &pvalue->transportCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "transportCapability", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.redundancyEncodingPresent = 1;
+
+                     invokeStartElement (pctxt, "redundancyEncoding", -1);
+
+                     stat = asn1PD_H245RedundancyEncoding (pctxt, &pvalue->redundancyEncoding);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "redundancyEncoding", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.sourcePresent = 1;
+
+                     invokeStartElement (pctxt, "source", -1);
+
+                     stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->source);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "source", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_forwardLogicalChannelParameters_multi  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* h222LogicalChannelParameters */
+         case 0:
+            invokeStartElement (pctxt, "h222LogicalChannelParameters", -1);
+
+            pvalue->u.h222LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H222LogicalChannelParameters);
+
+            stat = asn1PD_H245H222LogicalChannelParameters (pctxt, pvalue->u.h222LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h222LogicalChannelParameters", -1);
+
+            break;
+
+         /* h223LogicalChannelParameters */
+         case 1:
+            invokeStartElement (pctxt, "h223LogicalChannelParameters", -1);
+
+            pvalue->u.h223LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H223LogicalChannelParameters);
+
+            stat = asn1PD_H245H223LogicalChannelParameters (pctxt, pvalue->u.h223LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h223LogicalChannelParameters", -1);
+
+            break;
+
+         /* v76LogicalChannelParameters */
+         case 2:
+            invokeStartElement (pctxt, "v76LogicalChannelParameters", -1);
+
+            pvalue->u.v76LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245V76LogicalChannelParameters);
+
+            stat = asn1PD_H245V76LogicalChannelParameters (pctxt, pvalue->u.v76LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "v76LogicalChannelParameters", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* h2250LogicalChannelParameters */
+         case 4:
+            invokeStartElement (pctxt, "h2250LogicalChannelParameters", -1);
+
+            pvalue->u.h2250LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H2250LogicalChannelParameters);
+
+            stat = asn1PD_H245H2250LogicalChannelParameters (pctxt, pvalue->u.h2250LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h2250LogicalChannelParameters", -1);
+
+            break;
+
+         /* none */
+         case 5:
+            invokeStartElement (pctxt, "none", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "none", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_forwardLogicalChannelParameters        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.portNumberPresent = optbit;
+
+   /* decode portNumber */
+
+   if (pvalue->m.portNumberPresent) {
+      invokeStartElement (pctxt, "portNumber", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->portNumber, 0U, 65535U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->portNumber);
+
+      invokeEndElement (pctxt, "portNumber", -1);
+   }
+
+   /* decode dataType */
+
+   invokeStartElement (pctxt, "dataType", -1);
+
+   stat = asn1PD_H245DataType (pctxt, &pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "dataType", -1);
+
+   /* decode multiplexParameters */
+
+   invokeStartElement (pctxt, "multiplexParameters", -1);
+
+   stat = asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexParameters", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.forwardLogicalChannelDependencyPresent = 1;
+
+                     invokeStartElement (pctxt, "forwardLogicalChannelDependency", -1);
+
+                     stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelDependency);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "forwardLogicalChannelDependency", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.replacementForPresent = 1;
+
+                     invokeStartElement (pctxt, "replacementFor", -1);
+
+                     stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->replacementFor);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "replacementFor", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_reverseLogicalChannelParameters_multi  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* h223LogicalChannelParameters */
+         case 0:
+            invokeStartElement (pctxt, "h223LogicalChannelParameters", -1);
+
+            pvalue->u.h223LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H223LogicalChannelParameters);
+
+            stat = asn1PD_H245H223LogicalChannelParameters (pctxt, pvalue->u.h223LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h223LogicalChannelParameters", -1);
+
+            break;
+
+         /* v76LogicalChannelParameters */
+         case 1:
+            invokeStartElement (pctxt, "v76LogicalChannelParameters", -1);
+
+            pvalue->u.v76LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245V76LogicalChannelParameters);
+
+            stat = asn1PD_H245V76LogicalChannelParameters (pctxt, pvalue->u.v76LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "v76LogicalChannelParameters", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* h2250LogicalChannelParameters */
+         case 3:
+            invokeStartElement (pctxt, "h2250LogicalChannelParameters", -1);
+
+            pvalue->u.h2250LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H2250LogicalChannelParameters);
+
+            stat = asn1PD_H245H2250LogicalChannelParameters (pctxt, pvalue->u.h2250LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h2250LogicalChannelParameters", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_reverseLogicalChannelParameters        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.multiplexParametersPresent = optbit;
+
+   /* decode dataType */
+
+   invokeStartElement (pctxt, "dataType", -1);
+
+   stat = asn1PD_H245DataType (pctxt, &pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "dataType", -1);
+
+   /* decode multiplexParameters */
+
+   if (pvalue->m.multiplexParametersPresent) {
+      invokeStartElement (pctxt, "multiplexParameters", -1);
+
+      stat = asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "multiplexParameters", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.reverseLogicalChannelDependencyPresent = 1;
+
+                     invokeStartElement (pctxt, "reverseLogicalChannelDependency", -1);
+
+                     stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->reverseLogicalChannelDependency);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "reverseLogicalChannelDependency", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.replacementForPresent = 1;
+
+                     invokeStartElement (pctxt, "replacementFor", -1);
+
+                     stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->replacementFor);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "replacementFor", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_distribution                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NetworkAccessParameters_distribution (OOCTXT* pctxt, H245NetworkAccessParameters_distribution* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unicast */
+         case 0:
+            invokeStartElement (pctxt, "unicast", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unicast", -1);
+
+            break;
+
+         /* multicast */
+         case 1:
+            invokeStartElement (pctxt, "multicast", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "multicast", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_networkAddress                    */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet;
+
+EXTERN int asn1PD_H245NetworkAccessParameters_networkAddress (OOCTXT* pctxt, H245NetworkAccessParameters_networkAddress* pvalue)
+{
+   static Asn1SizeCnst e164Address_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* q2931Address */
+         case 0:
+            invokeStartElement (pctxt, "q2931Address", -1);
+
+            pvalue->u.q2931Address = ALLOC_ASN1ELEM (pctxt, H245Q2931Address);
+
+            stat = asn1PD_H245Q2931Address (pctxt, pvalue->u.q2931Address);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "q2931Address", -1);
+
+            break;
+
+         /* e164Address */
+         case 1:
+            invokeStartElement (pctxt, "e164Address", -1);
+
+            addSizeConstraint (pctxt, &e164Address_lsize1);
+
+            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.e164Address, gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet, 4, 4, 7);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.e164Address);
+
+            invokeEndElement (pctxt, "e164Address", -1);
+
+            break;
+
+         /* localAreaAddress */
+         case 2:
+            invokeStartElement (pctxt, "localAreaAddress", -1);
+
+            pvalue->u.localAreaAddress = ALLOC_ASN1ELEM (pctxt, H245TransportAddress);
+
+            stat = asn1PD_H245TransportAddress (pctxt, pvalue->u.localAreaAddress);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "localAreaAddress", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_externalReference                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NetworkAccessParameters_externalReference (OOCTXT* pctxt, H245NetworkAccessParameters_externalReference* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 255, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_t120SetupProcedure                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NetworkAccessParameters_t120SetupProcedure (OOCTXT* pctxt, H245NetworkAccessParameters_t120SetupProcedure* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* originateCall */
+         case 0:
+            invokeStartElement (pctxt, "originateCall", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "originateCall", -1);
+
+            break;
+
+         /* waitForCall */
+         case 1:
+            invokeStartElement (pctxt, "waitForCall", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "waitForCall", -1);
+
+            break;
+
+         /* issueQuery */
+         case 2:
+            invokeStartElement (pctxt, "issueQuery", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "issueQuery", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NetworkAccessParameters (OOCTXT* pctxt, H245NetworkAccessParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.distributionPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.externalReferencePresent = optbit;
+
+   /* decode distribution */
+
+   if (pvalue->m.distributionPresent) {
+      invokeStartElement (pctxt, "distribution", -1);
+
+      stat = asn1PD_H245NetworkAccessParameters_distribution (pctxt, &pvalue->distribution);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "distribution", -1);
+   }
+
+   /* decode networkAddress */
+
+   invokeStartElement (pctxt, "networkAddress", -1);
+
+   stat = asn1PD_H245NetworkAccessParameters_networkAddress (pctxt, &pvalue->networkAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "networkAddress", -1);
+
+   /* decode associateConference */
+
+   invokeStartElement (pctxt, "associateConference", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->associateConference);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->associateConference);
+
+   invokeEndElement (pctxt, "associateConference", -1);
+
+   /* decode externalReference */
+
+   if (pvalue->m.externalReferencePresent) {
+      invokeStartElement (pctxt, "externalReference", -1);
+
+      stat = asn1PD_H245NetworkAccessParameters_externalReference (pctxt, &pvalue->externalReference);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "externalReference", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.t120SetupProcedurePresent = 1;
+
+                     invokeStartElement (pctxt, "t120SetupProcedure", -1);
+
+                     stat = asn1PD_H245NetworkAccessParameters_t120SetupProcedure (pctxt, &pvalue->t120SetupProcedure);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "t120SetupProcedure", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EscrowData_escrowValue                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EscrowData_escrowValue (OOCTXT* pctxt, H245EscrowData_escrowValue* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeBitString (pctxt,
+                        &pvalue->numbits,
+                        pvalue->data,
+                        sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+
+   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EscrowData                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EscrowData (OOCTXT* pctxt, H245EscrowData* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode escrowID */
+
+   invokeStartElement (pctxt, "escrowID", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->escrowID);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->escrowID.numids, pvalue->escrowID.subid);
+
+   invokeEndElement (pctxt, "escrowID", -1);
+
+   /* decode escrowValue */
+
+   invokeStartElement (pctxt, "escrowValue", -1);
+
+   stat = asn1PD_H245EscrowData_escrowValue (pctxt, &pvalue->escrowValue);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "escrowValue", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionSync_escrowentry                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EncryptionSync_escrowentry (OOCTXT* pctxt, H245EncryptionSync_escrowentry* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245EscrowData* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245EscrowData);
+
+      stat = asn1PD_H245EscrowData (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionSync                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EncryptionSync (OOCTXT* pctxt, H245EncryptionSync* pvalue)
+{
+   static Asn1SizeCnst h235Key_lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.escrowentryPresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   /* decode synchFlag */
+
+   invokeStartElement (pctxt, "synchFlag", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->synchFlag, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->synchFlag);
+
+   invokeEndElement (pctxt, "synchFlag", -1);
+
+   /* decode h235Key */
+
+   invokeStartElement (pctxt, "h235Key", -1);
+
+   addSizeConstraint (pctxt, &h235Key_lsize1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->h235Key);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->h235Key.numocts, pvalue->h235Key.data);
+
+   invokeEndElement (pctxt, "h235Key", -1);
+
+   /* decode escrowentry */
+
+   if (pvalue->m.escrowentryPresent) {
+      invokeStartElement (pctxt, "escrowentry", -1);
+
+      stat = asn1PD_H245EncryptionSync_escrowentry (pctxt, &pvalue->escrowentry);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "escrowentry", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannel (OOCTXT* pctxt, H245OpenLogicalChannel* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.reverseLogicalChannelParametersPresent = optbit;
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   /* decode forwardLogicalChannelParameters */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelParameters", -1);
+
+   stat = asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters (pctxt, &pvalue->forwardLogicalChannelParameters);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelParameters", -1);
+
+   /* decode reverseLogicalChannelParameters */
+
+   if (pvalue->m.reverseLogicalChannelParametersPresent) {
+      invokeStartElement (pctxt, "reverseLogicalChannelParameters", -1);
+
+      stat = asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters (pctxt, &pvalue->reverseLogicalChannelParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "reverseLogicalChannelParameters", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.separateStackPresent = 1;
+
+                     invokeStartElement (pctxt, "separateStack", -1);
+
+                     stat = asn1PD_H245NetworkAccessParameters (pctxt, &pvalue->separateStack);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "separateStack", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.encryptionSyncPresent = 1;
+
+                     invokeStartElement (pctxt, "encryptionSync", -1);
+
+                     stat = asn1PD_H245EncryptionSync (pctxt, &pvalue->encryptionSync);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "encryptionSync", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel_source                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CloseLogicalChannel_source (OOCTXT* pctxt, H245CloseLogicalChannel_source* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* user */
+      case 0:
+         invokeStartElement (pctxt, "user", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "user", -1);
+
+         break;
+
+      /* lcse */
+      case 1:
+         invokeStartElement (pctxt, "lcse", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "lcse", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel_reason                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CloseLogicalChannel_reason (OOCTXT* pctxt, H245CloseLogicalChannel_reason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unknown */
+         case 0:
+            invokeStartElement (pctxt, "unknown", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unknown", -1);
+
+            break;
+
+         /* reopen */
+         case 1:
+            invokeStartElement (pctxt, "reopen", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "reopen", -1);
+
+            break;
+
+         /* reservationFailure */
+         case 2:
+            invokeStartElement (pctxt, "reservationFailure", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "reservationFailure", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CloseLogicalChannel (OOCTXT* pctxt, H245CloseLogicalChannel* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   /* decode source */
+
+   invokeStartElement (pctxt, "source", -1);
+
+   stat = asn1PD_H245CloseLogicalChannel_source (pctxt, &pvalue->source);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "source", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.reasonPresent = 1;
+
+                     invokeStartElement (pctxt, "reason", -1);
+
+                     stat = asn1PD_H245CloseLogicalChannel_reason (pctxt, &pvalue->reason);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "reason", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelClose_reason                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestChannelClose_reason (OOCTXT* pctxt, H245RequestChannelClose_reason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unknown */
+         case 0:
+            invokeStartElement (pctxt, "unknown", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unknown", -1);
+
+            break;
+
+         /* normal */
+         case 1:
+            invokeStartElement (pctxt, "normal", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "normal", -1);
+
+            break;
+
+         /* reopen */
+         case 2:
+            invokeStartElement (pctxt, "reopen", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "reopen", -1);
+
+            break;
+
+         /* reservationFailure */
+         case 3:
+            invokeStartElement (pctxt, "reservationFailure", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "reservationFailure", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelClose                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestChannelClose (OOCTXT* pctxt, H245RequestChannelClose* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.qosCapabilityPresent = 1;
+
+                     invokeStartElement (pctxt, "qosCapability", -1);
+
+                     stat = asn1PD_H245QOSCapability (pctxt, &pvalue->qosCapability);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "qosCapability", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.reasonPresent = 1;
+
+                     invokeStartElement (pctxt, "reason", -1);
+
+                     stat = asn1PD_H245RequestChannelClose_reason (pctxt, &pvalue->reason);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "reason", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexTableEntryNumber                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexTableEntryNumber* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUInt8 (pctxt, pvalue, 1U, 15U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_type_subElementList                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexElement_type_subElementList (OOCTXT* pctxt, H245MultiplexElement_type_subElementList* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 255, 0 };
+   int stat = ASN_OK;
+   H245MultiplexElement* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MultiplexElement);
+
+      stat = asn1PD_H245MultiplexElement (pctxt, (H245MultiplexElement*)pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_type                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexElement_type (OOCTXT* pctxt, H245MultiplexElement_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* logicalChannelNumber */
+      case 0:
+         invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+         stat = decodeConsUInt16 (pctxt, &pvalue->u.logicalChannelNumber, 0U, 65535U);
+         if (stat != ASN_OK) return stat;
+         invokeUIntValue (pctxt, pvalue->u.logicalChannelNumber);
+
+         invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+         break;
+
+      /* subElementList */
+      case 1:
+         invokeStartElement (pctxt, "subElementList", -1);
+
+         pvalue->u.subElementList = ALLOC_ASN1ELEM (pctxt, H245MultiplexElement_type_subElementList);
+
+         stat = asn1PD_H245MultiplexElement_type_subElementList (pctxt, pvalue->u.subElementList);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "subElementList", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_repeatCount                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexElement_repeatCount (OOCTXT* pctxt, H245MultiplexElement_repeatCount* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* finite */
+      case 0:
+         invokeStartElement (pctxt, "finite", -1);
+
+         stat = decodeConsUInt16 (pctxt, &pvalue->u.finite, 1U, 65535U);
+         if (stat != ASN_OK) return stat;
+         invokeUIntValue (pctxt, pvalue->u.finite);
+
+         invokeEndElement (pctxt, "finite", -1);
+
+         break;
+
+      /* untilClosingFlag */
+      case 1:
+         invokeStartElement (pctxt, "untilClosingFlag", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "untilClosingFlag", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexElement (OOCTXT* pctxt, H245MultiplexElement* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245MultiplexElement_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   /* decode repeatCount */
+
+   invokeStartElement (pctxt, "repeatCount", -1);
+
+   stat = asn1PD_H245MultiplexElement_repeatCount (pctxt, &pvalue->repeatCount);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "repeatCount", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryDescriptor_elementList                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntryDescriptor_elementList (OOCTXT* pctxt, H245MultiplexEntryDescriptor_elementList* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245MultiplexElement* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MultiplexElement);
+
+      stat = asn1PD_H245MultiplexElement (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryDescriptor                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntryDescriptor (OOCTXT* pctxt, H245MultiplexEntryDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL optbit;
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.elementListPresent = optbit;
+
+   /* decode multiplexTableEntryNumber */
+
+   invokeStartElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   /* decode elementList */
+
+   if (pvalue->m.elementListPresent) {
+      invokeStartElement (pctxt, "elementList", -1);
+
+      stat = asn1PD_H245MultiplexEntryDescriptor_elementList (pctxt, &pvalue->elementList);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "elementList", -1);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySend_multiplexEntryDescriptors              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntrySend_multiplexEntryDescriptors (OOCTXT* pctxt, H245MultiplexEntrySend_multiplexEntryDescriptors* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   H245MultiplexEntryDescriptor* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MultiplexEntryDescriptor);
+
+      stat = asn1PD_H245MultiplexEntryDescriptor (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySend                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntrySend (OOCTXT* pctxt, H245MultiplexEntrySend* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode multiplexEntryDescriptors */
+
+   invokeStartElement (pctxt, "multiplexEntryDescriptors", -1);
+
+   stat = asn1PD_H245MultiplexEntrySend_multiplexEntryDescriptors (pctxt, &pvalue->multiplexEntryDescriptors);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexEntryDescriptors", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntry_entryNumbers                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntry_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntry_entryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntry                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntry (OOCTXT* pctxt, H245RequestMultiplexEntry* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode entryNumbers */
+
+   invokeStartElement (pctxt, "entryNumbers", -1);
+
+   stat = asn1PD_H245RequestMultiplexEntry_entryNumbers (pctxt, &pvalue->entryNumbers);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "entryNumbers", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoMode_resolution                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H261VideoMode_resolution (OOCTXT* pctxt, H245H261VideoMode_resolution* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* qcif */
+      case 0:
+         invokeStartElement (pctxt, "qcif", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "qcif", -1);
+
+         break;
+
+      /* cif */
+      case 1:
+         invokeStartElement (pctxt, "cif", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "cif", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H261VideoMode (OOCTXT* pctxt, H245H261VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode resolution */
+
+   invokeStartElement (pctxt, "resolution", -1);
+
+   stat = asn1PD_H245H261VideoMode_resolution (pctxt, &pvalue->resolution);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "resolution", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 19200U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   /* decode stillImageTransmission */
+
+   invokeStartElement (pctxt, "stillImageTransmission", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->stillImageTransmission);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->stillImageTransmission);
+
+   invokeEndElement (pctxt, "stillImageTransmission", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoMode_profileAndLevel                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H262VideoMode_profileAndLevel (OOCTXT* pctxt, H245H262VideoMode_profileAndLevel* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 10);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* profileAndLevel_SPatML */
+         case 0:
+            invokeStartElement (pctxt, "profileAndLevel_SPatML", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_SPatML", -1);
+
+            break;
+
+         /* profileAndLevel_MPatLL */
+         case 1:
+            invokeStartElement (pctxt, "profileAndLevel_MPatLL", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_MPatLL", -1);
+
+            break;
+
+         /* profileAndLevel_MPatML */
+         case 2:
+            invokeStartElement (pctxt, "profileAndLevel_MPatML", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_MPatML", -1);
+
+            break;
+
+         /* profileAndLevel_MPatH_14 */
+         case 3:
+            invokeStartElement (pctxt, "profileAndLevel_MPatH_14", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_MPatH_14", -1);
+
+            break;
+
+         /* profileAndLevel_MPatHL */
+         case 4:
+            invokeStartElement (pctxt, "profileAndLevel_MPatHL", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_MPatHL", -1);
+
+            break;
+
+         /* profileAndLevel_SNRatLL */
+         case 5:
+            invokeStartElement (pctxt, "profileAndLevel_SNRatLL", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_SNRatLL", -1);
+
+            break;
+
+         /* profileAndLevel_SNRatML */
+         case 6:
+            invokeStartElement (pctxt, "profileAndLevel_SNRatML", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_SNRatML", -1);
+
+            break;
+
+         /* profileAndLevel_SpatialatH_14 */
+         case 7:
+            invokeStartElement (pctxt, "profileAndLevel_SpatialatH_14", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_SpatialatH_14", -1);
+
+            break;
+
+         /* profileAndLevel_HPatML */
+         case 8:
+            invokeStartElement (pctxt, "profileAndLevel_HPatML", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_HPatML", -1);
+
+            break;
+
+         /* profileAndLevel_HPatH_14 */
+         case 9:
+            invokeStartElement (pctxt, "profileAndLevel_HPatH_14", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_HPatH_14", -1);
+
+            break;
+
+         /* profileAndLevel_HPatHL */
+         case 10:
+            invokeStartElement (pctxt, "profileAndLevel_HPatHL", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "profileAndLevel_HPatHL", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 12;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H262VideoMode (OOCTXT* pctxt, H245H262VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.videoBitRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.vbvBufferSizePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.samplesPerLinePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.linesPerFramePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.framesPerSecondPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.luminanceSampleRatePresent = optbit;
+
+   /* decode profileAndLevel */
+
+   invokeStartElement (pctxt, "profileAndLevel", -1);
+
+   stat = asn1PD_H245H262VideoMode_profileAndLevel (pctxt, &pvalue->profileAndLevel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "profileAndLevel", -1);
+
+   /* decode videoBitRate */
+
+   if (pvalue->m.videoBitRatePresent) {
+      invokeStartElement (pctxt, "videoBitRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->videoBitRate, 0U, 1073741823U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->videoBitRate);
+
+      invokeEndElement (pctxt, "videoBitRate", -1);
+   }
+
+   /* decode vbvBufferSize */
+
+   if (pvalue->m.vbvBufferSizePresent) {
+      invokeStartElement (pctxt, "vbvBufferSize", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->vbvBufferSize, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->vbvBufferSize);
+
+      invokeEndElement (pctxt, "vbvBufferSize", -1);
+   }
+
+   /* decode samplesPerLine */
+
+   if (pvalue->m.samplesPerLinePresent) {
+      invokeStartElement (pctxt, "samplesPerLine", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->samplesPerLine, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->samplesPerLine);
+
+      invokeEndElement (pctxt, "samplesPerLine", -1);
+   }
+
+   /* decode linesPerFrame */
+
+   if (pvalue->m.linesPerFramePresent) {
+      invokeStartElement (pctxt, "linesPerFrame", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->linesPerFrame, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->linesPerFrame);
+
+      invokeEndElement (pctxt, "linesPerFrame", -1);
+   }
+
+   /* decode framesPerSecond */
+
+   if (pvalue->m.framesPerSecondPresent) {
+      invokeStartElement (pctxt, "framesPerSecond", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->framesPerSecond, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->framesPerSecond);
+
+      invokeEndElement (pctxt, "framesPerSecond", -1);
+   }
+
+   /* decode luminanceSampleRate */
+
+   if (pvalue->m.luminanceSampleRatePresent) {
+      invokeStartElement (pctxt, "luminanceSampleRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->luminanceSampleRate);
+
+      invokeEndElement (pctxt, "luminanceSampleRate", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoMode_resolution                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263VideoMode_resolution (OOCTXT* pctxt, H245H263VideoMode_resolution* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* sqcif */
+         case 0:
+            invokeStartElement (pctxt, "sqcif", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "sqcif", -1);
+
+            break;
+
+         /* qcif */
+         case 1:
+            invokeStartElement (pctxt, "qcif", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "qcif", -1);
+
+            break;
+
+         /* cif */
+         case 2:
+            invokeStartElement (pctxt, "cif", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cif", -1);
+
+            break;
+
+         /* cif4 */
+         case 3:
+            invokeStartElement (pctxt, "cif4", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cif4", -1);
+
+            break;
+
+         /* cif16 */
+         case 4:
+            invokeStartElement (pctxt, "cif16", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cif16", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* custom */
+         case 6:
+            invokeStartElement (pctxt, "custom", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "custom", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H263VideoMode (OOCTXT* pctxt, H245H263VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode resolution */
+
+   invokeStartElement (pctxt, "resolution", -1);
+
+   stat = asn1PD_H245H263VideoMode_resolution (pctxt, &pvalue->resolution);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "resolution", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 19200U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   /* decode unrestrictedVector */
+
+   invokeStartElement (pctxt, "unrestrictedVector", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->unrestrictedVector);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->unrestrictedVector);
+
+   invokeEndElement (pctxt, "unrestrictedVector", -1);
+
+   /* decode arithmeticCoding */
+
+   invokeStartElement (pctxt, "arithmeticCoding", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->arithmeticCoding);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->arithmeticCoding);
+
+   invokeEndElement (pctxt, "arithmeticCoding", -1);
+
+   /* decode advancedPrediction */
+
+   invokeStartElement (pctxt, "advancedPrediction", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->advancedPrediction);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->advancedPrediction);
+
+   invokeEndElement (pctxt, "advancedPrediction", -1);
+
+   /* decode pbFrames */
+
+   invokeStartElement (pctxt, "pbFrames", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->pbFrames);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->pbFrames);
+
+   invokeEndElement (pctxt, "pbFrames", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 3 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.errorCompensationPresent = 1;
+
+                     invokeStartElement (pctxt, "errorCompensation", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->errorCompensation);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->errorCompensation);
+
+                     invokeEndElement (pctxt, "errorCompensation", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.enhancementLayerInfoPresent = 1;
+
+                     invokeStartElement (pctxt, "enhancementLayerInfo", -1);
+
+                     stat = asn1PD_H245EnhancementLayerInfo (pctxt, &pvalue->enhancementLayerInfo);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "enhancementLayerInfo", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.h263OptionsPresent = 1;
+
+                     invokeStartElement (pctxt, "h263Options", -1);
+
+                     stat = asn1PD_H245H263Options (pctxt, &pvalue->h263Options);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h263Options", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172VideoMode                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS11172VideoMode (OOCTXT* pctxt, H245IS11172VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.videoBitRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.vbvBufferSizePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.samplesPerLinePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.linesPerFramePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.pictureRatePresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.luminanceSampleRatePresent = optbit;
+
+   /* decode constrainedBitstream */
+
+   invokeStartElement (pctxt, "constrainedBitstream", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->constrainedBitstream);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->constrainedBitstream);
+
+   invokeEndElement (pctxt, "constrainedBitstream", -1);
+
+   /* decode videoBitRate */
+
+   if (pvalue->m.videoBitRatePresent) {
+      invokeStartElement (pctxt, "videoBitRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->videoBitRate, 0U, 1073741823U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->videoBitRate);
+
+      invokeEndElement (pctxt, "videoBitRate", -1);
+   }
+
+   /* decode vbvBufferSize */
+
+   if (pvalue->m.vbvBufferSizePresent) {
+      invokeStartElement (pctxt, "vbvBufferSize", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->vbvBufferSize, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->vbvBufferSize);
+
+      invokeEndElement (pctxt, "vbvBufferSize", -1);
+   }
+
+   /* decode samplesPerLine */
+
+   if (pvalue->m.samplesPerLinePresent) {
+      invokeStartElement (pctxt, "samplesPerLine", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->samplesPerLine, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->samplesPerLine);
+
+      invokeEndElement (pctxt, "samplesPerLine", -1);
+   }
+
+   /* decode linesPerFrame */
+
+   if (pvalue->m.linesPerFramePresent) {
+      invokeStartElement (pctxt, "linesPerFrame", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->linesPerFrame, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->linesPerFrame);
+
+      invokeEndElement (pctxt, "linesPerFrame", -1);
+   }
+
+   /* decode pictureRate */
+
+   if (pvalue->m.pictureRatePresent) {
+      invokeStartElement (pctxt, "pictureRate", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->pictureRate, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->pictureRate);
+
+      invokeEndElement (pctxt, "pictureRate", -1);
+   }
+
+   /* decode luminanceSampleRate */
+
+   if (pvalue->m.luminanceSampleRatePresent) {
+      invokeStartElement (pctxt, "luminanceSampleRate", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->luminanceSampleRate);
+
+      invokeEndElement (pctxt, "luminanceSampleRate", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VideoMode                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VideoMode (OOCTXT* pctxt, H245VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* h261VideoMode */
+         case 1:
+            invokeStartElement (pctxt, "h261VideoMode", -1);
+
+            pvalue->u.h261VideoMode = ALLOC_ASN1ELEM (pctxt, H245H261VideoMode);
+
+            stat = asn1PD_H245H261VideoMode (pctxt, pvalue->u.h261VideoMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h261VideoMode", -1);
+
+            break;
+
+         /* h262VideoMode */
+         case 2:
+            invokeStartElement (pctxt, "h262VideoMode", -1);
+
+            pvalue->u.h262VideoMode = ALLOC_ASN1ELEM (pctxt, H245H262VideoMode);
+
+            stat = asn1PD_H245H262VideoMode (pctxt, pvalue->u.h262VideoMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h262VideoMode", -1);
+
+            break;
+
+         /* h263VideoMode */
+         case 3:
+            invokeStartElement (pctxt, "h263VideoMode", -1);
+
+            pvalue->u.h263VideoMode = ALLOC_ASN1ELEM (pctxt, H245H263VideoMode);
+
+            stat = asn1PD_H245H263VideoMode (pctxt, pvalue->u.h263VideoMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h263VideoMode", -1);
+
+            break;
+
+         /* is11172VideoMode */
+         case 4:
+            invokeStartElement (pctxt, "is11172VideoMode", -1);
+
+            pvalue->u.is11172VideoMode = ALLOC_ASN1ELEM (pctxt, H245IS11172VideoMode);
+
+            stat = asn1PD_H245IS11172VideoMode (pctxt, pvalue->u.is11172VideoMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "is11172VideoMode", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* genericVideoMode */
+         case 6:
+            invokeStartElement (pctxt, "genericVideoMode", -1);
+
+            pvalue->u.genericVideoMode = ALLOC_ASN1ELEM (pctxt, H245GenericCapability);
+
+            stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericVideoMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericVideoMode", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioMode_g7231                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245AudioMode_g7231 (OOCTXT* pctxt, H245AudioMode_g7231* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* noSilenceSuppressionLowRate */
+      case 0:
+         invokeStartElement (pctxt, "noSilenceSuppressionLowRate", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "noSilenceSuppressionLowRate", -1);
+
+         break;
+
+      /* noSilenceSuppressionHighRate */
+      case 1:
+         invokeStartElement (pctxt, "noSilenceSuppressionHighRate", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "noSilenceSuppressionHighRate", -1);
+
+         break;
+
+      /* silenceSuppressionLowRate */
+      case 2:
+         invokeStartElement (pctxt, "silenceSuppressionLowRate", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "silenceSuppressionLowRate", -1);
+
+         break;
+
+      /* silenceSuppressionHighRate */
+      case 3:
+         invokeStartElement (pctxt, "silenceSuppressionHighRate", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "silenceSuppressionHighRate", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_audioLayer                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS11172AudioMode_audioLayer (OOCTXT* pctxt, H245IS11172AudioMode_audioLayer* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* audioLayer1 */
+      case 0:
+         invokeStartElement (pctxt, "audioLayer1", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioLayer1", -1);
+
+         break;
+
+      /* audioLayer2 */
+      case 1:
+         invokeStartElement (pctxt, "audioLayer2", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioLayer2", -1);
+
+         break;
+
+      /* audioLayer3 */
+      case 2:
+         invokeStartElement (pctxt, "audioLayer3", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioLayer3", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_audioSampling                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS11172AudioMode_audioSampling (OOCTXT* pctxt, H245IS11172AudioMode_audioSampling* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* audioSampling32k */
+      case 0:
+         invokeStartElement (pctxt, "audioSampling32k", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling32k", -1);
+
+         break;
+
+      /* audioSampling44k1 */
+      case 1:
+         invokeStartElement (pctxt, "audioSampling44k1", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling44k1", -1);
+
+         break;
+
+      /* audioSampling48k */
+      case 2:
+         invokeStartElement (pctxt, "audioSampling48k", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling48k", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_multichannelType                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS11172AudioMode_multichannelType (OOCTXT* pctxt, H245IS11172AudioMode_multichannelType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* singleChannel */
+      case 0:
+         invokeStartElement (pctxt, "singleChannel", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "singleChannel", -1);
+
+         break;
+
+      /* twoChannelStereo */
+      case 1:
+         invokeStartElement (pctxt, "twoChannelStereo", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "twoChannelStereo", -1);
+
+         break;
+
+      /* twoChannelDual */
+      case 2:
+         invokeStartElement (pctxt, "twoChannelDual", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "twoChannelDual", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS11172AudioMode (OOCTXT* pctxt, H245IS11172AudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode audioLayer */
+
+   invokeStartElement (pctxt, "audioLayer", -1);
+
+   stat = asn1PD_H245IS11172AudioMode_audioLayer (pctxt, &pvalue->audioLayer);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "audioLayer", -1);
+
+   /* decode audioSampling */
+
+   invokeStartElement (pctxt, "audioSampling", -1);
+
+   stat = asn1PD_H245IS11172AudioMode_audioSampling (pctxt, &pvalue->audioSampling);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "audioSampling", -1);
+
+   /* decode multichannelType */
+
+   invokeStartElement (pctxt, "multichannelType", -1);
+
+   stat = asn1PD_H245IS11172AudioMode_multichannelType (pctxt, &pvalue->multichannelType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multichannelType", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 448U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_audioLayer                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS13818AudioMode_audioLayer (OOCTXT* pctxt, H245IS13818AudioMode_audioLayer* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* audioLayer1 */
+      case 0:
+         invokeStartElement (pctxt, "audioLayer1", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioLayer1", -1);
+
+         break;
+
+      /* audioLayer2 */
+      case 1:
+         invokeStartElement (pctxt, "audioLayer2", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioLayer2", -1);
+
+         break;
+
+      /* audioLayer3 */
+      case 2:
+         invokeStartElement (pctxt, "audioLayer3", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioLayer3", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_audioSampling                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS13818AudioMode_audioSampling (OOCTXT* pctxt, H245IS13818AudioMode_audioSampling* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* audioSampling16k */
+      case 0:
+         invokeStartElement (pctxt, "audioSampling16k", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling16k", -1);
+
+         break;
+
+      /* audioSampling22k05 */
+      case 1:
+         invokeStartElement (pctxt, "audioSampling22k05", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling22k05", -1);
+
+         break;
+
+      /* audioSampling24k */
+      case 2:
+         invokeStartElement (pctxt, "audioSampling24k", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling24k", -1);
+
+         break;
+
+      /* audioSampling32k */
+      case 3:
+         invokeStartElement (pctxt, "audioSampling32k", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling32k", -1);
+
+         break;
+
+      /* audioSampling44k1 */
+      case 4:
+         invokeStartElement (pctxt, "audioSampling44k1", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling44k1", -1);
+
+         break;
+
+      /* audioSampling48k */
+      case 5:
+         invokeStartElement (pctxt, "audioSampling48k", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "audioSampling48k", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_multichannelType                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS13818AudioMode_multichannelType (OOCTXT* pctxt, H245IS13818AudioMode_multichannelType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 9);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* singleChannel */
+      case 0:
+         invokeStartElement (pctxt, "singleChannel", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "singleChannel", -1);
+
+         break;
+
+      /* twoChannelStereo */
+      case 1:
+         invokeStartElement (pctxt, "twoChannelStereo", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "twoChannelStereo", -1);
+
+         break;
+
+      /* twoChannelDual */
+      case 2:
+         invokeStartElement (pctxt, "twoChannelDual", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "twoChannelDual", -1);
+
+         break;
+
+      /* threeChannels2_1 */
+      case 3:
+         invokeStartElement (pctxt, "threeChannels2_1", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "threeChannels2_1", -1);
+
+         break;
+
+      /* threeChannels3_0 */
+      case 4:
+         invokeStartElement (pctxt, "threeChannels3_0", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "threeChannels3_0", -1);
+
+         break;
+
+      /* fourChannels2_0_2_0 */
+      case 5:
+         invokeStartElement (pctxt, "fourChannels2_0_2_0", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "fourChannels2_0_2_0", -1);
+
+         break;
+
+      /* fourChannels2_2 */
+      case 6:
+         invokeStartElement (pctxt, "fourChannels2_2", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "fourChannels2_2", -1);
+
+         break;
+
+      /* fourChannels3_1 */
+      case 7:
+         invokeStartElement (pctxt, "fourChannels3_1", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "fourChannels3_1", -1);
+
+         break;
+
+      /* fiveChannels3_0_2_0 */
+      case 8:
+         invokeStartElement (pctxt, "fiveChannels3_0_2_0", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "fiveChannels3_0_2_0", -1);
+
+         break;
+
+      /* fiveChannels3_2 */
+      case 9:
+         invokeStartElement (pctxt, "fiveChannels3_2", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "fiveChannels3_2", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IS13818AudioMode (OOCTXT* pctxt, H245IS13818AudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode audioLayer */
+
+   invokeStartElement (pctxt, "audioLayer", -1);
+
+   stat = asn1PD_H245IS13818AudioMode_audioLayer (pctxt, &pvalue->audioLayer);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "audioLayer", -1);
+
+   /* decode audioSampling */
+
+   invokeStartElement (pctxt, "audioSampling", -1);
+
+   stat = asn1PD_H245IS13818AudioMode_audioSampling (pctxt, &pvalue->audioSampling);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "audioSampling", -1);
+
+   /* decode multichannelType */
+
+   invokeStartElement (pctxt, "multichannelType", -1);
+
+   stat = asn1PD_H245IS13818AudioMode_multichannelType (pctxt, &pvalue->multichannelType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multichannelType", -1);
+
+   /* decode lowFrequencyEnhancement */
+
+   invokeStartElement (pctxt, "lowFrequencyEnhancement", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->lowFrequencyEnhancement);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->lowFrequencyEnhancement);
+
+   invokeEndElement (pctxt, "lowFrequencyEnhancement", -1);
+
+   /* decode multilingual */
+
+   invokeStartElement (pctxt, "multilingual", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->multilingual);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->multilingual);
+
+   invokeEndElement (pctxt, "multilingual", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 1130U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCMode_g723AnnexCAudioMode                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245G7231AnnexCMode_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCMode_g723AnnexCAudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode highRateMode0 */
+
+   invokeStartElement (pctxt, "highRateMode0", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->highRateMode0, 27U, 78U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->highRateMode0);
+
+   invokeEndElement (pctxt, "highRateMode0", -1);
+
+   /* decode highRateMode1 */
+
+   invokeStartElement (pctxt, "highRateMode1", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->highRateMode1, 27U, 78U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->highRateMode1);
+
+   invokeEndElement (pctxt, "highRateMode1", -1);
+
+   /* decode lowRateMode0 */
+
+   invokeStartElement (pctxt, "lowRateMode0", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->lowRateMode0, 23U, 66U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->lowRateMode0);
+
+   invokeEndElement (pctxt, "lowRateMode0", -1);
+
+   /* decode lowRateMode1 */
+
+   invokeStartElement (pctxt, "lowRateMode1", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->lowRateMode1, 23U, 66U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->lowRateMode1);
+
+   invokeEndElement (pctxt, "lowRateMode1", -1);
+
+   /* decode sidMode0 */
+
+   invokeStartElement (pctxt, "sidMode0", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sidMode0, 6U, 17U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sidMode0);
+
+   invokeEndElement (pctxt, "sidMode0", -1);
+
+   /* decode sidMode1 */
+
+   invokeStartElement (pctxt, "sidMode1", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sidMode1, 6U, 17U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sidMode1);
+
+   invokeEndElement (pctxt, "sidMode1", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCMode                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245G7231AnnexCMode (OOCTXT* pctxt, H245G7231AnnexCMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode maxAl_sduAudioFrames */
+
+   invokeStartElement (pctxt, "maxAl_sduAudioFrames", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maxAl_sduAudioFrames, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxAl_sduAudioFrames);
+
+   invokeEndElement (pctxt, "maxAl_sduAudioFrames", -1);
+
+   /* decode silenceSuppression */
+
+   invokeStartElement (pctxt, "silenceSuppression", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->silenceSuppression);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->silenceSuppression);
+
+   invokeEndElement (pctxt, "silenceSuppression", -1);
+
+   /* decode g723AnnexCAudioMode */
+
+   invokeStartElement (pctxt, "g723AnnexCAudioMode", -1);
+
+   stat = asn1PD_H245G7231AnnexCMode_g723AnnexCAudioMode (pctxt, &pvalue->g723AnnexCAudioMode);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "g723AnnexCAudioMode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VBDMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VBDMode (OOCTXT* pctxt, H245VBDMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   pvalue->type = ALLOC_ASN1ELEM (pctxt, H245AudioMode);
+
+   stat = asn1PD_H245AudioMode (pctxt, (H245AudioMode*)pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioMode                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245AudioMode (OOCTXT* pctxt, H245AudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 13);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* g711Alaw64k */
+         case 1:
+            invokeStartElement (pctxt, "g711Alaw64k", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g711Alaw64k", -1);
+
+            break;
+
+         /* g711Alaw56k */
+         case 2:
+            invokeStartElement (pctxt, "g711Alaw56k", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g711Alaw56k", -1);
+
+            break;
+
+         /* g711Ulaw64k */
+         case 3:
+            invokeStartElement (pctxt, "g711Ulaw64k", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g711Ulaw64k", -1);
+
+            break;
+
+         /* g711Ulaw56k */
+         case 4:
+            invokeStartElement (pctxt, "g711Ulaw56k", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g711Ulaw56k", -1);
+
+            break;
+
+         /* g722_64k */
+         case 5:
+            invokeStartElement (pctxt, "g722_64k", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g722_64k", -1);
+
+            break;
+
+         /* g722_56k */
+         case 6:
+            invokeStartElement (pctxt, "g722_56k", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g722_56k", -1);
+
+            break;
+
+         /* g722_48k */
+         case 7:
+            invokeStartElement (pctxt, "g722_48k", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g722_48k", -1);
+
+            break;
+
+         /* g728 */
+         case 8:
+            invokeStartElement (pctxt, "g728", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g728", -1);
+
+            break;
+
+         /* g729 */
+         case 9:
+            invokeStartElement (pctxt, "g729", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g729", -1);
+
+            break;
+
+         /* g729AnnexA */
+         case 10:
+            invokeStartElement (pctxt, "g729AnnexA", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "g729AnnexA", -1);
+
+            break;
+
+         /* g7231 */
+         case 11:
+            invokeStartElement (pctxt, "g7231", -1);
+
+            pvalue->u.g7231 = ALLOC_ASN1ELEM (pctxt, H245AudioMode_g7231);
+
+            stat = asn1PD_H245AudioMode_g7231 (pctxt, pvalue->u.g7231);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "g7231", -1);
+
+            break;
+
+         /* is11172AudioMode */
+         case 12:
+            invokeStartElement (pctxt, "is11172AudioMode", -1);
+
+            pvalue->u.is11172AudioMode = ALLOC_ASN1ELEM (pctxt, H245IS11172AudioMode);
+
+            stat = asn1PD_H245IS11172AudioMode (pctxt, pvalue->u.is11172AudioMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "is11172AudioMode", -1);
+
+            break;
+
+         /* is13818AudioMode */
+         case 13:
+            invokeStartElement (pctxt, "is13818AudioMode", -1);
+
+            pvalue->u.is13818AudioMode = ALLOC_ASN1ELEM (pctxt, H245IS13818AudioMode);
+
+            stat = asn1PD_H245IS13818AudioMode (pctxt, pvalue->u.is13818AudioMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "is13818AudioMode", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 15;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* g729wAnnexB */
+         case 15:
+            invokeStartElement (pctxt, "g729wAnnexB", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g729wAnnexB, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g729wAnnexB);
+
+            invokeEndElement (pctxt, "g729wAnnexB", -1);
+
+            break;
+
+         /* g729AnnexAwAnnexB */
+         case 16:
+            invokeStartElement (pctxt, "g729AnnexAwAnnexB", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.g729AnnexAwAnnexB, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.g729AnnexAwAnnexB);
+
+            invokeEndElement (pctxt, "g729AnnexAwAnnexB", -1);
+
+            break;
+
+         /* g7231AnnexCMode */
+         case 17:
+            invokeStartElement (pctxt, "g7231AnnexCMode", -1);
+
+            pvalue->u.g7231AnnexCMode = ALLOC_ASN1ELEM (pctxt, H245G7231AnnexCMode);
+
+            stat = asn1PD_H245G7231AnnexCMode (pctxt, pvalue->u.g7231AnnexCMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "g7231AnnexCMode", -1);
+
+            break;
+
+         /* gsmFullRate */
+         case 18:
+            invokeStartElement (pctxt, "gsmFullRate", -1);
+
+            pvalue->u.gsmFullRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability);
+
+            stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmFullRate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gsmFullRate", -1);
+
+            break;
+
+         /* gsmHalfRate */
+         case 19:
+            invokeStartElement (pctxt, "gsmHalfRate", -1);
+
+            pvalue->u.gsmHalfRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability);
+
+            stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmHalfRate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gsmHalfRate", -1);
+
+            break;
+
+         /* gsmEnhancedFullRate */
+         case 20:
+            invokeStartElement (pctxt, "gsmEnhancedFullRate", -1);
+
+            pvalue->u.gsmEnhancedFullRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability);
+
+            stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmEnhancedFullRate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gsmEnhancedFullRate", -1);
+
+            break;
+
+         /* genericAudioMode */
+         case 21:
+            invokeStartElement (pctxt, "genericAudioMode", -1);
+
+            pvalue->u.genericAudioMode = ALLOC_ASN1ELEM (pctxt, H245GenericCapability);
+
+            stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericAudioMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericAudioMode", -1);
+
+            break;
+
+         /* g729Extensions */
+         case 22:
+            invokeStartElement (pctxt, "g729Extensions", -1);
+
+            pvalue->u.g729Extensions = ALLOC_ASN1ELEM (pctxt, H245G729Extensions);
+
+            stat = asn1PD_H245G729Extensions (pctxt, pvalue->u.g729Extensions);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "g729Extensions", -1);
+
+            break;
+
+         /* vbd */
+         case 23:
+            invokeStartElement (pctxt, "vbd", -1);
+
+            pvalue->u.vbd = ALLOC_ASN1ELEM (pctxt, H245VBDMode);
+
+            stat = asn1PD_H245VBDMode (pctxt, pvalue->u.vbd);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "vbd", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application_nlpid                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataMode_application_nlpid (OOCTXT* pctxt, H245DataMode_application_nlpid* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode nlpidProtocol */
+
+   invokeStartElement (pctxt, "nlpidProtocol", -1);
+
+   stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->nlpidProtocol);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "nlpidProtocol", -1);
+
+   /* decode nlpidData */
+
+   invokeStartElement (pctxt, "nlpidData", -1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->nlpidData);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->nlpidData.numocts, pvalue->nlpidData.data);
+
+   invokeEndElement (pctxt, "nlpidData", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application_t38fax                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataMode_application_t38fax (OOCTXT* pctxt, H245DataMode_application_t38fax* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode t38FaxProtocol */
+
+   invokeStartElement (pctxt, "t38FaxProtocol", -1);
+
+   stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t38FaxProtocol", -1);
+
+   /* decode t38FaxProfile */
+
+   invokeStartElement (pctxt, "t38FaxProfile", -1);
+
+   stat = asn1PD_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "t38FaxProfile", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataMode_application (OOCTXT* pctxt, H245DataMode_application* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 9);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* t120 */
+         case 1:
+            invokeStartElement (pctxt, "t120", -1);
+
+            pvalue->u.t120 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t120);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t120", -1);
+
+            break;
+
+         /* dsm_cc */
+         case 2:
+            invokeStartElement (pctxt, "dsm_cc", -1);
+
+            pvalue->u.dsm_cc = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.dsm_cc);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "dsm_cc", -1);
+
+            break;
+
+         /* userData */
+         case 3:
+            invokeStartElement (pctxt, "userData", -1);
+
+            pvalue->u.userData = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.userData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "userData", -1);
+
+            break;
+
+         /* t84 */
+         case 4:
+            invokeStartElement (pctxt, "t84", -1);
+
+            pvalue->u.t84 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t84);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t84", -1);
+
+            break;
+
+         /* t434 */
+         case 5:
+            invokeStartElement (pctxt, "t434", -1);
+
+            pvalue->u.t434 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t434);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t434", -1);
+
+            break;
+
+         /* h224 */
+         case 6:
+            invokeStartElement (pctxt, "h224", -1);
+
+            pvalue->u.h224 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.h224);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h224", -1);
+
+            break;
+
+         /* nlpid */
+         case 7:
+            invokeStartElement (pctxt, "nlpid", -1);
+
+            pvalue->u.nlpid = ALLOC_ASN1ELEM (pctxt, H245DataMode_application_nlpid);
+
+            stat = asn1PD_H245DataMode_application_nlpid (pctxt, pvalue->u.nlpid);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nlpid", -1);
+
+            break;
+
+         /* dsvdControl */
+         case 8:
+            invokeStartElement (pctxt, "dsvdControl", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "dsvdControl", -1);
+
+            break;
+
+         /* h222DataPartitioning */
+         case 9:
+            invokeStartElement (pctxt, "h222DataPartitioning", -1);
+
+            pvalue->u.h222DataPartitioning = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.h222DataPartitioning);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h222DataPartitioning", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 11;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* t30fax */
+         case 11:
+            invokeStartElement (pctxt, "t30fax", -1);
+
+            pvalue->u.t30fax = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t30fax);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t30fax", -1);
+
+            break;
+
+         /* t140 */
+         case 12:
+            invokeStartElement (pctxt, "t140", -1);
+
+            pvalue->u.t140 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability);
+
+            stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t140);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t140", -1);
+
+            break;
+
+         /* t38fax */
+         case 13:
+            invokeStartElement (pctxt, "t38fax", -1);
+
+            pvalue->u.t38fax = ALLOC_ASN1ELEM (pctxt, H245DataMode_application_t38fax);
+
+            stat = asn1PD_H245DataMode_application_t38fax (pctxt, pvalue->u.t38fax);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "t38fax", -1);
+
+            break;
+
+         /* genericDataMode */
+         case 14:
+            invokeStartElement (pctxt, "genericDataMode", -1);
+
+            pvalue->u.genericDataMode = ALLOC_ASN1ELEM (pctxt, H245GenericCapability);
+
+            stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericDataMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "genericDataMode", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DataMode (OOCTXT* pctxt, H245DataMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode application */
+
+   invokeStartElement (pctxt, "application", -1);
+
+   stat = asn1PD_H245DataMode_application (pctxt, &pvalue->application);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "application", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->bitRate, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235Mode_mediaMode                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H235Mode_mediaMode (OOCTXT* pctxt, H245H235Mode_mediaMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* videoMode */
+         case 1:
+            invokeStartElement (pctxt, "videoMode", -1);
+
+            pvalue->u.videoMode = ALLOC_ASN1ELEM (pctxt, H245VideoMode);
+
+            stat = asn1PD_H245VideoMode (pctxt, pvalue->u.videoMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoMode", -1);
+
+            break;
+
+         /* audioMode */
+         case 2:
+            invokeStartElement (pctxt, "audioMode", -1);
+
+            pvalue->u.audioMode = ALLOC_ASN1ELEM (pctxt, H245AudioMode);
+
+            stat = asn1PD_H245AudioMode (pctxt, pvalue->u.audioMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioMode", -1);
+
+            break;
+
+         /* dataMode */
+         case 3:
+            invokeStartElement (pctxt, "dataMode", -1);
+
+            pvalue->u.dataMode = ALLOC_ASN1ELEM (pctxt, H245DataMode);
+
+            stat = asn1PD_H245DataMode (pctxt, pvalue->u.dataMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "dataMode", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235Mode                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H235Mode (OOCTXT* pctxt, H245H235Mode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode encryptionAuthenticationAndIntegrity */
+
+   invokeStartElement (pctxt, "encryptionAuthenticationAndIntegrity", -1);
+
+   stat = asn1PD_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "encryptionAuthenticationAndIntegrity", -1);
+
+   /* decode mediaMode */
+
+   invokeStartElement (pctxt, "mediaMode", -1);
+
+   stat = asn1PD_H245H235Mode_mediaMode (pctxt, &pvalue->mediaMode);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mediaMode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTModeElement_type                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingDTModeElement_type (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* videoMode */
+         case 1:
+            invokeStartElement (pctxt, "videoMode", -1);
+
+            pvalue->u.videoMode = ALLOC_ASN1ELEM (pctxt, H245VideoMode);
+
+            stat = asn1PD_H245VideoMode (pctxt, pvalue->u.videoMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoMode", -1);
+
+            break;
+
+         /* audioMode */
+         case 2:
+            invokeStartElement (pctxt, "audioMode", -1);
+
+            pvalue->u.audioMode = ALLOC_ASN1ELEM (pctxt, H245AudioMode);
+
+            stat = asn1PD_H245AudioMode (pctxt, pvalue->u.audioMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioMode", -1);
+
+            break;
+
+         /* dataMode */
+         case 3:
+            invokeStartElement (pctxt, "dataMode", -1);
+
+            pvalue->u.dataMode = ALLOC_ASN1ELEM (pctxt, H245DataMode);
+
+            stat = asn1PD_H245DataMode (pctxt, pvalue->u.dataMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "dataMode", -1);
+
+            break;
+
+         /* encryptionMode */
+         case 4:
+            invokeStartElement (pctxt, "encryptionMode", -1);
+
+            pvalue->u.encryptionMode = ALLOC_ASN1ELEM (pctxt, H245EncryptionMode);
+
+            stat = asn1PD_H245EncryptionMode (pctxt, pvalue->u.encryptionMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "encryptionMode", -1);
+
+            break;
+
+         /* h235Mode */
+         case 5:
+            invokeStartElement (pctxt, "h235Mode", -1);
+
+            pvalue->u.h235Mode = ALLOC_ASN1ELEM (pctxt, H245H235Mode);
+
+            stat = asn1PD_H245H235Mode (pctxt, pvalue->u.h235Mode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h235Mode", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTModeElement                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245RedundancyEncodingDTModeElement_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245RedundancyEncodingDTModeElement                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingDTModeElement* pvalue)
+{
+   int stat = ASN_OK;
+   H245RedundancyEncodingDTModeElement* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245RedundancyEncodingDTModeElement);
+
+         stat = asn1PD_H245RedundancyEncodingDTModeElement (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTMode                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingDTMode (OOCTXT* pctxt, H245RedundancyEncodingDTMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode redundancyEncodingMethod */
+
+   invokeStartElement (pctxt, "redundancyEncodingMethod", -1);
+
+   stat = asn1PD_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "redundancyEncodingMethod", -1);
+
+   /* decode primary */
+
+   invokeStartElement (pctxt, "primary", -1);
+
+   stat = asn1PD_H245RedundancyEncodingDTModeElement (pctxt, &pvalue->primary);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "primary", -1);
+
+   /* decode secondary */
+
+   invokeStartElement (pctxt, "secondary", -1);
+
+   stat = asn1PD_H245_SeqOfH245RedundancyEncodingDTModeElement (pctxt, &pvalue->secondary);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "secondary", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamElementMode                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245MultiplePayloadStreamElementMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   pvalue->type = ALLOC_ASN1ELEM (pctxt, H245ModeElementType);
+
+   stat = asn1PD_H245ModeElementType (pctxt, (H245ModeElementType*)pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MultiplePayloadStreamElementMode                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElementMode* pvalue)
+{
+   int stat = ASN_OK;
+   H245MultiplePayloadStreamElementMode* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MultiplePayloadStreamElementMode);
+
+         stat = asn1PD_H245MultiplePayloadStreamElementMode (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamMode                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplePayloadStreamMode (OOCTXT* pctxt, H245MultiplePayloadStreamMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode elements */
+
+   invokeStartElement (pctxt, "elements", -1);
+
+   stat = asn1PD_H245_SeqOfH245MultiplePayloadStreamElementMode (pctxt, &pvalue->elements);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "elements", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream_differentPort     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.protectedPayloadTypePresent = optbit;
+
+   /* decode protectedSessionID */
+
+   invokeStartElement (pctxt, "protectedSessionID", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->protectedSessionID, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->protectedSessionID);
+
+   invokeEndElement (pctxt, "protectedSessionID", -1);
+
+   /* decode protectedPayloadType */
+
+   if (pvalue->m.protectedPayloadTypePresent) {
+      invokeStartElement (pctxt, "protectedPayloadType", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->protectedPayloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->protectedPayloadType);
+
+      invokeEndElement (pctxt, "protectedPayloadType", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream_samePort          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_samePort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode protectedType */
+
+   invokeStartElement (pctxt, "protectedType", -1);
+
+   pvalue->protectedType = ALLOC_ASN1ELEM (pctxt, H245ModeElementType);
+
+   stat = asn1PD_H245ModeElementType (pctxt, (H245ModeElementType*)pvalue->protectedType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "protectedType", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* differentPort */
+         case 0:
+            invokeStartElement (pctxt, "differentPort", -1);
+
+            pvalue->u.differentPort = ALLOC_ASN1ELEM (pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort);
+
+            stat = asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (pctxt, pvalue->u.differentPort);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "differentPort", -1);
+
+            break;
+
+         /* samePort */
+         case 1:
+            invokeStartElement (pctxt, "samePort", -1);
+
+            pvalue->u.samePort = ALLOC_ASN1ELEM (pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort);
+
+            stat = asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_samePort (pctxt, pvalue->u.samePort);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "samePort", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* redundancyEncoding */
+         case 0:
+            invokeStartElement (pctxt, "redundancyEncoding", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "redundancyEncoding", -1);
+
+            break;
+
+         /* separateStream */
+         case 1:
+            invokeStartElement (pctxt, "separateStream", -1);
+
+            pvalue->u.separateStream = ALLOC_ASN1ELEM (pctxt, H245FECMode_rfc2733Mode_mode_separateStream);
+
+            stat = asn1PD_H245FECMode_rfc2733Mode_mode_separateStream (pctxt, pvalue->u.separateStream);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "separateStream", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECMode_rfc2733Mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode mode */
+
+   invokeStartElement (pctxt, "mode", -1);
+
+   stat = asn1PD_H245FECMode_rfc2733Mode_mode (pctxt, &pvalue->mode);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "mode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FECMode (OOCTXT* pctxt, H245FECMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* rfc2733Mode */
+         case 0:
+            invokeStartElement (pctxt, "rfc2733Mode", -1);
+
+            pvalue->u.rfc2733Mode = ALLOC_ASN1ELEM (pctxt, H245FECMode_rfc2733Mode);
+
+            stat = asn1PD_H245FECMode_rfc2733Mode (pctxt, pvalue->u.rfc2733Mode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "rfc2733Mode", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ModeElementType                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ModeElementType (OOCTXT* pctxt, H245ModeElementType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* videoMode */
+         case 1:
+            invokeStartElement (pctxt, "videoMode", -1);
+
+            pvalue->u.videoMode = ALLOC_ASN1ELEM (pctxt, H245VideoMode);
+
+            stat = asn1PD_H245VideoMode (pctxt, pvalue->u.videoMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoMode", -1);
+
+            break;
+
+         /* audioMode */
+         case 2:
+            invokeStartElement (pctxt, "audioMode", -1);
+
+            pvalue->u.audioMode = ALLOC_ASN1ELEM (pctxt, H245AudioMode);
+
+            stat = asn1PD_H245AudioMode (pctxt, pvalue->u.audioMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioMode", -1);
+
+            break;
+
+         /* dataMode */
+         case 3:
+            invokeStartElement (pctxt, "dataMode", -1);
+
+            pvalue->u.dataMode = ALLOC_ASN1ELEM (pctxt, H245DataMode);
+
+            stat = asn1PD_H245DataMode (pctxt, pvalue->u.dataMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "dataMode", -1);
+
+            break;
+
+         /* encryptionMode */
+         case 4:
+            invokeStartElement (pctxt, "encryptionMode", -1);
+
+            pvalue->u.encryptionMode = ALLOC_ASN1ELEM (pctxt, H245EncryptionMode);
+
+            stat = asn1PD_H245EncryptionMode (pctxt, pvalue->u.encryptionMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "encryptionMode", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* h235Mode */
+         case 6:
+            invokeStartElement (pctxt, "h235Mode", -1);
+
+            pvalue->u.h235Mode = ALLOC_ASN1ELEM (pctxt, H245H235Mode);
+
+            stat = asn1PD_H245H235Mode (pctxt, pvalue->u.h235Mode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h235Mode", -1);
+
+            break;
+
+         /* multiplexedStreamMode */
+         case 7:
+            invokeStartElement (pctxt, "multiplexedStreamMode", -1);
+
+            pvalue->u.multiplexedStreamMode = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamParameter);
+
+            stat = asn1PD_H245MultiplexedStreamParameter (pctxt, pvalue->u.multiplexedStreamMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplexedStreamMode", -1);
+
+            break;
+
+         /* redundancyEncodingDTMode */
+         case 8:
+            invokeStartElement (pctxt, "redundancyEncodingDTMode", -1);
+
+            pvalue->u.redundancyEncodingDTMode = ALLOC_ASN1ELEM (pctxt, H245RedundancyEncodingDTMode);
+
+            stat = asn1PD_H245RedundancyEncodingDTMode (pctxt, pvalue->u.redundancyEncodingDTMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "redundancyEncodingDTMode", -1);
+
+            break;
+
+         /* multiplePayloadStreamMode */
+         case 9:
+            invokeStartElement (pctxt, "multiplePayloadStreamMode", -1);
+
+            pvalue->u.multiplePayloadStreamMode = ALLOC_ASN1ELEM (pctxt, H245MultiplePayloadStreamMode);
+
+            stat = asn1PD_H245MultiplePayloadStreamMode (pctxt, pvalue->u.multiplePayloadStreamMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplePayloadStreamMode", -1);
+
+            break;
+
+         /* fecMode */
+         case 10:
+            invokeStartElement (pctxt, "fecMode", -1);
+
+            pvalue->u.fecMode = ALLOC_ASN1ELEM (pctxt, H245FECMode);
+
+            stat = asn1PD_H245FECMode (pctxt, pvalue->u.fecMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "fecMode", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters_adaptationLayerType_al3                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223ModeParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType_al3* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode controlFieldOctets */
+
+   invokeStartElement (pctxt, "controlFieldOctets", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->controlFieldOctets, 0U, 2U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->controlFieldOctets);
+
+   invokeEndElement (pctxt, "controlFieldOctets", -1);
+
+   /* decode sendBufferSize */
+
+   invokeStartElement (pctxt, "sendBufferSize", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->sendBufferSize, 0U, 16777215U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sendBufferSize);
+
+   invokeEndElement (pctxt, "sendBufferSize", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters_adaptationLayerType                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223ModeParameters_adaptationLayerType (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* al1Framed */
+         case 1:
+            invokeStartElement (pctxt, "al1Framed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "al1Framed", -1);
+
+            break;
+
+         /* al1NotFramed */
+         case 2:
+            invokeStartElement (pctxt, "al1NotFramed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "al1NotFramed", -1);
+
+            break;
+
+         /* al2WithoutSequenceNumbers */
+         case 3:
+            invokeStartElement (pctxt, "al2WithoutSequenceNumbers", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "al2WithoutSequenceNumbers", -1);
+
+            break;
+
+         /* al2WithSequenceNumbers */
+         case 4:
+            invokeStartElement (pctxt, "al2WithSequenceNumbers", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "al2WithSequenceNumbers", -1);
+
+            break;
+
+         /* al3 */
+         case 5:
+            invokeStartElement (pctxt, "al3", -1);
+
+            pvalue->u.al3 = ALLOC_ASN1ELEM (pctxt, H245H223ModeParameters_adaptationLayerType_al3);
+
+            stat = asn1PD_H245H223ModeParameters_adaptationLayerType_al3 (pctxt, pvalue->u.al3);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "al3", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* al1M */
+         case 7:
+            invokeStartElement (pctxt, "al1M", -1);
+
+            pvalue->u.al1M = ALLOC_ASN1ELEM (pctxt, H245H223AL1MParameters);
+
+            stat = asn1PD_H245H223AL1MParameters (pctxt, pvalue->u.al1M);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "al1M", -1);
+
+            break;
+
+         /* al2M */
+         case 8:
+            invokeStartElement (pctxt, "al2M", -1);
+
+            pvalue->u.al2M = ALLOC_ASN1ELEM (pctxt, H245H223AL2MParameters);
+
+            stat = asn1PD_H245H223AL2MParameters (pctxt, pvalue->u.al2M);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "al2M", -1);
+
+            break;
+
+         /* al3M */
+         case 9:
+            invokeStartElement (pctxt, "al3M", -1);
+
+            pvalue->u.al3M = ALLOC_ASN1ELEM (pctxt, H245H223AL3MParameters);
+
+            stat = asn1PD_H245H223AL3MParameters (pctxt, pvalue->u.al3M);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "al3M", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223ModeParameters (OOCTXT* pctxt, H245H223ModeParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode adaptationLayerType */
+
+   invokeStartElement (pctxt, "adaptationLayerType", -1);
+
+   stat = asn1PD_H245H223ModeParameters_adaptationLayerType (pctxt, &pvalue->adaptationLayerType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "adaptationLayerType", -1);
+
+   /* decode segmentableFlag */
+
+   invokeStartElement (pctxt, "segmentableFlag", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->segmentableFlag);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->segmentableFlag);
+
+   invokeEndElement (pctxt, "segmentableFlag", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76ModeParameters                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245V76ModeParameters (OOCTXT* pctxt, H245V76ModeParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* suspendResumewAddress */
+         case 0:
+            invokeStartElement (pctxt, "suspendResumewAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "suspendResumewAddress", -1);
+
+            break;
+
+         /* suspendResumewoAddress */
+         case 1:
+            invokeStartElement (pctxt, "suspendResumewoAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "suspendResumewoAddress", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMode_secondaryEncoding                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingMode_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingMode_secondaryEncoding* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* audioData */
+         case 1:
+            invokeStartElement (pctxt, "audioData", -1);
+
+            pvalue->u.audioData = ALLOC_ASN1ELEM (pctxt, H245AudioMode);
+
+            stat = asn1PD_H245AudioMode (pctxt, pvalue->u.audioData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioData", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMode                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RedundancyEncodingMode (OOCTXT* pctxt, H245RedundancyEncodingMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.secondaryEncodingPresent = optbit;
+
+   /* decode redundancyEncodingMethod */
+
+   invokeStartElement (pctxt, "redundancyEncodingMethod", -1);
+
+   stat = asn1PD_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "redundancyEncodingMethod", -1);
+
+   /* decode secondaryEncoding */
+
+   if (pvalue->m.secondaryEncodingPresent) {
+      invokeStartElement (pctxt, "secondaryEncoding", -1);
+
+      stat = asn1PD_H245RedundancyEncodingMode_secondaryEncoding (pctxt, &pvalue->secondaryEncoding);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "secondaryEncoding", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250ModeParameters                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H2250ModeParameters (OOCTXT* pctxt, H245H2250ModeParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.redundancyEncodingModePresent = optbit;
+
+   /* decode redundancyEncodingMode */
+
+   if (pvalue->m.redundancyEncodingModePresent) {
+      invokeStartElement (pctxt, "redundancyEncodingMode", -1);
+
+      stat = asn1PD_H245RedundancyEncodingMode (pctxt, &pvalue->redundancyEncodingMode);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "redundancyEncodingMode", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamModeParameters                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexedStreamModeParameters (OOCTXT* pctxt, H245MultiplexedStreamModeParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode logicalChannelNumber */
+
+   invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ModeElement                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ModeElement (OOCTXT* pctxt, H245ModeElement* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.h223ModeParametersPresent = optbit;
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245ModeElementType (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   /* decode h223ModeParameters */
+
+   if (pvalue->m.h223ModeParametersPresent) {
+      invokeStartElement (pctxt, "h223ModeParameters", -1);
+
+      stat = asn1PD_H245H223ModeParameters (pctxt, &pvalue->h223ModeParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "h223ModeParameters", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 4 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.v76ModeParametersPresent = 1;
+
+                     invokeStartElement (pctxt, "v76ModeParameters", -1);
+
+                     stat = asn1PD_H245V76ModeParameters (pctxt, &pvalue->v76ModeParameters);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "v76ModeParameters", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.h2250ModeParametersPresent = 1;
+
+                     invokeStartElement (pctxt, "h2250ModeParameters", -1);
+
+                     stat = asn1PD_H245H2250ModeParameters (pctxt, &pvalue->h2250ModeParameters);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "h2250ModeParameters", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.genericModeParametersPresent = 1;
+
+                     invokeStartElement (pctxt, "genericModeParameters", -1);
+
+                     stat = asn1PD_H245GenericCapability (pctxt, &pvalue->genericModeParameters);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "genericModeParameters", -1);
+                     break;
+
+                  case 3:
+                     pvalue->m.multiplexedStreamModeParametersPresent = 1;
+
+                     invokeStartElement (pctxt, "multiplexedStreamModeParameters", -1);
+
+                     stat = asn1PD_H245MultiplexedStreamModeParameters (pctxt, &pvalue->multiplexedStreamModeParameters);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "multiplexedStreamModeParameters", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ModeDescription                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ModeDescription (OOCTXT* pctxt, H245ModeDescription* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245ModeElement* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245ModeElement);
+
+      stat = asn1PD_H245ModeElement (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMode_requestedModes                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMode_requestedModes (OOCTXT* pctxt, H245RequestMode_requestedModes* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245ModeDescription* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245ModeDescription);
+
+      stat = asn1PD_H245ModeDescription (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMode                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMode (OOCTXT* pctxt, H245RequestMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode requestedModes */
+
+   invokeStartElement (pctxt, "requestedModes", -1);
+
+   stat = asn1PD_H245RequestMode_requestedModes (pctxt, &pvalue->requestedModes);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestedModes", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RoundTripDelayRequest                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RoundTripDelayRequest (OOCTXT* pctxt, H245RoundTripDelayRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopRequest_type                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaintenanceLoopRequest_type (OOCTXT* pctxt, H245MaintenanceLoopRequest_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* systemLoop */
+         case 0:
+            invokeStartElement (pctxt, "systemLoop", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "systemLoop", -1);
+
+            break;
+
+         /* mediaLoop */
+         case 1:
+            invokeStartElement (pctxt, "mediaLoop", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.mediaLoop);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "mediaLoop", -1);
+
+            break;
+
+         /* logicalChannelLoop */
+         case 2:
+            invokeStartElement (pctxt, "logicalChannelLoop", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelLoop);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "logicalChannelLoop", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopRequest                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaintenanceLoopRequest (OOCTXT* pctxt, H245MaintenanceLoopRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245MaintenanceLoopRequest_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeRequest                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CommunicationModeRequest (OOCTXT* pctxt, H245CommunicationModeRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Criteria                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245Criteria (OOCTXT* pctxt, H245Criteria* pvalue)
+{
+   static Asn1SizeCnst value_lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode field */
+
+   invokeStartElement (pctxt, "field", -1);
+
+   stat = decodeObjectIdentifier (pctxt, &pvalue->field);
+   if (stat != ASN_OK) return stat;
+   invokeOidValue (pctxt, pvalue->field.numids, pvalue->field.subid);
+
+   invokeEndElement (pctxt, "field", -1);
+
+   /* decode value */
+
+   invokeStartElement (pctxt, "value", -1);
+
+   addSizeConstraint (pctxt, &value_lsize1);
+
+   stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->value);
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->value.numocts, pvalue->value.data);
+
+   invokeEndElement (pctxt, "value", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CertSelectionCriteria                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CertSelectionCriteria (OOCTXT* pctxt, H245CertSelectionCriteria* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   H245Criteria* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245Criteria);
+
+      stat = asn1PD_H245Criteria (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceRequest_requestTerminalCertificate              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceRequest_requestTerminalCertificate (OOCTXT* pctxt, H245ConferenceRequest_requestTerminalCertificate* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalLabelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.certSelectionCriteriaPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sRandomPresent = optbit;
+
+   /* decode terminalLabel */
+
+   if (pvalue->m.terminalLabelPresent) {
+      invokeStartElement (pctxt, "terminalLabel", -1);
+
+      stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminalLabel", -1);
+   }
+
+   /* decode certSelectionCriteria */
+
+   if (pvalue->m.certSelectionCriteriaPresent) {
+      invokeStartElement (pctxt, "certSelectionCriteria", -1);
+
+      stat = asn1PD_H245CertSelectionCriteria (pctxt, &pvalue->certSelectionCriteria);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "certSelectionCriteria", -1);
+   }
+
+   /* decode sRandom */
+
+   if (pvalue->m.sRandomPresent) {
+      invokeStartElement (pctxt, "sRandom", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->sRandom, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->sRandom);
+
+      invokeEndElement (pctxt, "sRandom", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCRequest                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RemoteMCRequest (OOCTXT* pctxt, H245RemoteMCRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* masterActivate */
+         case 0:
+            invokeStartElement (pctxt, "masterActivate", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "masterActivate", -1);
+
+            break;
+
+         /* slaveActivate */
+         case 1:
+            invokeStartElement (pctxt, "slaveActivate", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "slaveActivate", -1);
+
+            break;
+
+         /* deActivate */
+         case 2:
+            invokeStartElement (pctxt, "deActivate", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "deActivate", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceRequest                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceRequest (OOCTXT* pctxt, H245ConferenceRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* terminalListRequest */
+         case 0:
+            invokeStartElement (pctxt, "terminalListRequest", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "terminalListRequest", -1);
+
+            break;
+
+         /* makeMeChair */
+         case 1:
+            invokeStartElement (pctxt, "makeMeChair", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "makeMeChair", -1);
+
+            break;
+
+         /* cancelMakeMeChair */
+         case 2:
+            invokeStartElement (pctxt, "cancelMakeMeChair", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelMakeMeChair", -1);
+
+            break;
+
+         /* dropTerminal */
+         case 3:
+            invokeStartElement (pctxt, "dropTerminal", -1);
+
+            pvalue->u.dropTerminal = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.dropTerminal);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "dropTerminal", -1);
+
+            break;
+
+         /* requestTerminalID */
+         case 4:
+            invokeStartElement (pctxt, "requestTerminalID", -1);
+
+            pvalue->u.requestTerminalID = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.requestTerminalID);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestTerminalID", -1);
+
+            break;
+
+         /* enterH243Password */
+         case 5:
+            invokeStartElement (pctxt, "enterH243Password", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "enterH243Password", -1);
+
+            break;
+
+         /* enterH243TerminalID */
+         case 6:
+            invokeStartElement (pctxt, "enterH243TerminalID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "enterH243TerminalID", -1);
+
+            break;
+
+         /* enterH243ConferenceID */
+         case 7:
+            invokeStartElement (pctxt, "enterH243ConferenceID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "enterH243ConferenceID", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 9;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* enterExtensionAddress */
+         case 9:
+            invokeStartElement (pctxt, "enterExtensionAddress", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "enterExtensionAddress", -1);
+
+            break;
+
+         /* requestChairTokenOwner */
+         case 10:
+            invokeStartElement (pctxt, "requestChairTokenOwner", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "requestChairTokenOwner", -1);
+
+            break;
+
+         /* requestTerminalCertificate */
+         case 11:
+            invokeStartElement (pctxt, "requestTerminalCertificate", -1);
+
+            pvalue->u.requestTerminalCertificate = ALLOC_ASN1ELEM (pctxt, H245ConferenceRequest_requestTerminalCertificate);
+
+            stat = asn1PD_H245ConferenceRequest_requestTerminalCertificate (pctxt, pvalue->u.requestTerminalCertificate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestTerminalCertificate", -1);
+
+            break;
+
+         /* broadcastMyLogicalChannel */
+         case 12:
+            invokeStartElement (pctxt, "broadcastMyLogicalChannel", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.broadcastMyLogicalChannel);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "broadcastMyLogicalChannel", -1);
+
+            break;
+
+         /* makeTerminalBroadcaster */
+         case 13:
+            invokeStartElement (pctxt, "makeTerminalBroadcaster", -1);
+
+            pvalue->u.makeTerminalBroadcaster = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.makeTerminalBroadcaster);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "makeTerminalBroadcaster", -1);
+
+            break;
+
+         /* sendThisSource */
+         case 14:
+            invokeStartElement (pctxt, "sendThisSource", -1);
+
+            pvalue->u.sendThisSource = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.sendThisSource);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "sendThisSource", -1);
+
+            break;
+
+         /* requestAllTerminalIDs */
+         case 15:
+            invokeStartElement (pctxt, "requestAllTerminalIDs", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "requestAllTerminalIDs", -1);
+
+            break;
+
+         /* remoteMCRequest */
+         case 16:
+            invokeStartElement (pctxt, "remoteMCRequest", -1);
+
+            pvalue->u.remoteMCRequest = ALLOC_ASN1ELEM (pctxt, H245RemoteMCRequest);
+
+            stat = asn1PD_H245RemoteMCRequest (pctxt, pvalue->u.remoteMCRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "remoteMCRequest", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_callInformation                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkRequest_callInformation (OOCTXT* pctxt, H245MultilinkRequest_callInformation* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode maxNumberOfAdditionalConnections */
+
+   invokeStartElement (pctxt, "maxNumberOfAdditionalConnections", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maxNumberOfAdditionalConnections, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maxNumberOfAdditionalConnections);
+
+   invokeEndElement (pctxt, "maxNumberOfAdditionalConnections", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNetworkType                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DialingInformationNetworkType (OOCTXT* pctxt, H245DialingInformationNetworkType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* n_isdn */
+         case 1:
+            invokeStartElement (pctxt, "n_isdn", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "n_isdn", -1);
+
+            break;
+
+         /* gstn */
+         case 2:
+            invokeStartElement (pctxt, "gstn", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "gstn", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* mobile */
+         case 4:
+            invokeStartElement (pctxt, "mobile", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "mobile", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNumber_networkType                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DialingInformationNumber_networkType (OOCTXT* pctxt, H245DialingInformationNumber_networkType* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 255, 0 };
+   int stat = ASN_OK;
+   H245DialingInformationNetworkType* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245DialingInformationNetworkType);
+
+      stat = asn1PD_H245DialingInformationNetworkType (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNumber                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DialingInformationNumber (OOCTXT* pctxt, H245DialingInformationNumber* pvalue)
+{
+   static Asn1SizeCnst networkAddress_lsize1 = { 0, 0, 40, 0 };
+   static Asn1SizeCnst subAddress_lsize1 = { 0, 1, 40, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.subAddressPresent = optbit;
+
+   /* decode networkAddress */
+
+   invokeStartElement (pctxt, "networkAddress", -1);
+
+   addSizeConstraint (pctxt, &networkAddress_lsize1);
+
+   stat = decodeConstrainedStringEx (pctxt, &pvalue->networkAddress, NUM_CANSET, 4, 4, 4);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, pvalue->networkAddress);
+
+   invokeEndElement (pctxt, "networkAddress", -1);
+
+   /* decode subAddress */
+
+   if (pvalue->m.subAddressPresent) {
+      invokeStartElement (pctxt, "subAddress", -1);
+
+      addSizeConstraint (pctxt, &subAddress_lsize1);
+
+      stat = decodeConstrainedStringEx (pctxt, &pvalue->subAddress, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+      invokeCharStrValue (pctxt, pvalue->subAddress);
+
+      invokeEndElement (pctxt, "subAddress", -1);
+   }
+
+   /* decode networkType */
+
+   invokeStartElement (pctxt, "networkType", -1);
+
+   stat = asn1PD_H245DialingInformationNumber_networkType (pctxt, &pvalue->networkType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "networkType", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformation_differential                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DialingInformation_differential (OOCTXT* pctxt, H245DialingInformation_differential* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   H245DialingInformationNumber* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245DialingInformationNumber);
+
+      stat = asn1PD_H245DialingInformationNumber (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformation                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245DialingInformation (OOCTXT* pctxt, H245DialingInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* differential */
+         case 1:
+            invokeStartElement (pctxt, "differential", -1);
+
+            pvalue->u.differential = ALLOC_ASN1ELEM (pctxt, H245DialingInformation_differential);
+
+            stat = asn1PD_H245DialingInformation_differential (pctxt, pvalue->u.differential);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "differential", -1);
+
+            break;
+
+         /* infoNotAvailable */
+         case 2:
+            invokeStartElement (pctxt, "infoNotAvailable", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.infoNotAvailable, 1U, 65535U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.infoNotAvailable);
+
+            invokeEndElement (pctxt, "infoNotAvailable", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_addConnection                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkRequest_addConnection (OOCTXT* pctxt, H245MultilinkRequest_addConnection* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode dialingInformation */
+
+   invokeStartElement (pctxt, "dialingInformation", -1);
+
+   stat = asn1PD_H245DialingInformation (pctxt, &pvalue->dialingInformation);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "dialingInformation", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConnectionIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConnectionIdentifier (OOCTXT* pctxt, H245ConnectionIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode channelTag */
+
+   invokeStartElement (pctxt, "channelTag", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->channelTag, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->channelTag);
+
+   invokeEndElement (pctxt, "channelTag", -1);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->sequenceNumber, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sequenceNumber);
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_removeConnection                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkRequest_removeConnection (OOCTXT* pctxt, H245MultilinkRequest_removeConnection* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode connectionIdentifier */
+
+   invokeStartElement (pctxt, "connectionIdentifier", -1);
+
+   stat = asn1PD_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "connectionIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_maximumHeaderInterval_requestType        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkRequest_maximumHeaderInterval_requestType (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval_requestType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* currentIntervalInformation */
+         case 0:
+            invokeStartElement (pctxt, "currentIntervalInformation", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "currentIntervalInformation", -1);
+
+            break;
+
+         /* requestedInterval */
+         case 1:
+            invokeStartElement (pctxt, "requestedInterval", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.requestedInterval, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.requestedInterval);
+
+            invokeEndElement (pctxt, "requestedInterval", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_maximumHeaderInterval                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkRequest_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode requestType */
+
+   invokeStartElement (pctxt, "requestType", -1);
+
+   stat = asn1PD_H245MultilinkRequest_maximumHeaderInterval_requestType (pctxt, &pvalue->requestType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "requestType", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkRequest (OOCTXT* pctxt, H245MultilinkRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* callInformation */
+         case 1:
+            invokeStartElement (pctxt, "callInformation", -1);
+
+            pvalue->u.callInformation = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest_callInformation);
+
+            stat = asn1PD_H245MultilinkRequest_callInformation (pctxt, pvalue->u.callInformation);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "callInformation", -1);
+
+            break;
+
+         /* addConnection */
+         case 2:
+            invokeStartElement (pctxt, "addConnection", -1);
+
+            pvalue->u.addConnection = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest_addConnection);
+
+            stat = asn1PD_H245MultilinkRequest_addConnection (pctxt, pvalue->u.addConnection);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "addConnection", -1);
+
+            break;
+
+         /* removeConnection */
+         case 3:
+            invokeStartElement (pctxt, "removeConnection", -1);
+
+            pvalue->u.removeConnection = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest_removeConnection);
+
+            stat = asn1PD_H245MultilinkRequest_removeConnection (pctxt, pvalue->u.removeConnection);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "removeConnection", -1);
+
+            break;
+
+         /* maximumHeaderInterval */
+         case 4:
+            invokeStartElement (pctxt, "maximumHeaderInterval", -1);
+
+            pvalue->u.maximumHeaderInterval = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest_maximumHeaderInterval);
+
+            stat = asn1PD_H245MultilinkRequest_maximumHeaderInterval (pctxt, pvalue->u.maximumHeaderInterval);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "maximumHeaderInterval", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaximumBitRate                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaximumBitRate (OOCTXT* pctxt, H245MaximumBitRate* pvalue)
+{
+   int stat = ASN_OK;
+
+   stat = decodeConsUnsigned (pctxt, pvalue, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, *pvalue);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRequest                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245LogicalChannelRateRequest (OOCTXT* pctxt, H245LogicalChannelRateRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode logicalChannelNumber */
+
+   invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+   /* decode maximumBitRate */
+
+   invokeStartElement (pctxt, "maximumBitRate", -1);
+
+   stat = asn1PD_H245MaximumBitRate (pctxt, &pvalue->maximumBitRate);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "maximumBitRate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMessage                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMessage (OOCTXT* pctxt, H245RequestMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 10);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* masterSlaveDetermination */
+         case 1:
+            invokeStartElement (pctxt, "masterSlaveDetermination", -1);
+
+            pvalue->u.masterSlaveDetermination = ALLOC_ASN1ELEM (pctxt, H245MasterSlaveDetermination);
+
+            stat = asn1PD_H245MasterSlaveDetermination (pctxt, pvalue->u.masterSlaveDetermination);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "masterSlaveDetermination", -1);
+
+            break;
+
+         /* terminalCapabilitySet */
+         case 2:
+            invokeStartElement (pctxt, "terminalCapabilitySet", -1);
+
+            pvalue->u.terminalCapabilitySet = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySet);
+
+            stat = asn1PD_H245TerminalCapabilitySet (pctxt, pvalue->u.terminalCapabilitySet);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalCapabilitySet", -1);
+
+            break;
+
+         /* openLogicalChannel */
+         case 3:
+            invokeStartElement (pctxt, "openLogicalChannel", -1);
+
+            pvalue->u.openLogicalChannel = ALLOC_ASN1ELEM (pctxt, H245OpenLogicalChannel);
+
+            stat = asn1PD_H245OpenLogicalChannel (pctxt, pvalue->u.openLogicalChannel);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "openLogicalChannel", -1);
+
+            break;
+
+         /* closeLogicalChannel */
+         case 4:
+            invokeStartElement (pctxt, "closeLogicalChannel", -1);
+
+            pvalue->u.closeLogicalChannel = ALLOC_ASN1ELEM (pctxt, H245CloseLogicalChannel);
+
+            stat = asn1PD_H245CloseLogicalChannel (pctxt, pvalue->u.closeLogicalChannel);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "closeLogicalChannel", -1);
+
+            break;
+
+         /* requestChannelClose */
+         case 5:
+            invokeStartElement (pctxt, "requestChannelClose", -1);
+
+            pvalue->u.requestChannelClose = ALLOC_ASN1ELEM (pctxt, H245RequestChannelClose);
+
+            stat = asn1PD_H245RequestChannelClose (pctxt, pvalue->u.requestChannelClose);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestChannelClose", -1);
+
+            break;
+
+         /* multiplexEntrySend */
+         case 6:
+            invokeStartElement (pctxt, "multiplexEntrySend", -1);
+
+            pvalue->u.multiplexEntrySend = ALLOC_ASN1ELEM (pctxt, H245MultiplexEntrySend);
+
+            stat = asn1PD_H245MultiplexEntrySend (pctxt, pvalue->u.multiplexEntrySend);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplexEntrySend", -1);
+
+            break;
+
+         /* requestMultiplexEntry */
+         case 7:
+            invokeStartElement (pctxt, "requestMultiplexEntry", -1);
+
+            pvalue->u.requestMultiplexEntry = ALLOC_ASN1ELEM (pctxt, H245RequestMultiplexEntry);
+
+            stat = asn1PD_H245RequestMultiplexEntry (pctxt, pvalue->u.requestMultiplexEntry);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestMultiplexEntry", -1);
+
+            break;
+
+         /* requestMode */
+         case 8:
+            invokeStartElement (pctxt, "requestMode", -1);
+
+            pvalue->u.requestMode = ALLOC_ASN1ELEM (pctxt, H245RequestMode);
+
+            stat = asn1PD_H245RequestMode (pctxt, pvalue->u.requestMode);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestMode", -1);
+
+            break;
+
+         /* roundTripDelayRequest */
+         case 9:
+            invokeStartElement (pctxt, "roundTripDelayRequest", -1);
+
+            pvalue->u.roundTripDelayRequest = ALLOC_ASN1ELEM (pctxt, H245RoundTripDelayRequest);
+
+            stat = asn1PD_H245RoundTripDelayRequest (pctxt, pvalue->u.roundTripDelayRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "roundTripDelayRequest", -1);
+
+            break;
+
+         /* maintenanceLoopRequest */
+         case 10:
+            invokeStartElement (pctxt, "maintenanceLoopRequest", -1);
+
+            pvalue->u.maintenanceLoopRequest = ALLOC_ASN1ELEM (pctxt, H245MaintenanceLoopRequest);
+
+            stat = asn1PD_H245MaintenanceLoopRequest (pctxt, pvalue->u.maintenanceLoopRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "maintenanceLoopRequest", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 12;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* communicationModeRequest */
+         case 12:
+            invokeStartElement (pctxt, "communicationModeRequest", -1);
+
+            pvalue->u.communicationModeRequest = ALLOC_ASN1ELEM (pctxt, H245CommunicationModeRequest);
+
+            stat = asn1PD_H245CommunicationModeRequest (pctxt, pvalue->u.communicationModeRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "communicationModeRequest", -1);
+
+            break;
+
+         /* conferenceRequest */
+         case 13:
+            invokeStartElement (pctxt, "conferenceRequest", -1);
+
+            pvalue->u.conferenceRequest = ALLOC_ASN1ELEM (pctxt, H245ConferenceRequest);
+
+            stat = asn1PD_H245ConferenceRequest (pctxt, pvalue->u.conferenceRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "conferenceRequest", -1);
+
+            break;
+
+         /* multilinkRequest */
+         case 14:
+            invokeStartElement (pctxt, "multilinkRequest", -1);
+
+            pvalue->u.multilinkRequest = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest);
+
+            stat = asn1PD_H245MultilinkRequest (pctxt, pvalue->u.multilinkRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multilinkRequest", -1);
+
+            break;
+
+         /* logicalChannelRateRequest */
+         case 15:
+            invokeStartElement (pctxt, "logicalChannelRateRequest", -1);
+
+            pvalue->u.logicalChannelRateRequest = ALLOC_ASN1ELEM (pctxt, H245LogicalChannelRateRequest);
+
+            stat = asn1PD_H245LogicalChannelRateRequest (pctxt, pvalue->u.logicalChannelRateRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "logicalChannelRateRequest", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationAck_decision                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationAck_decision (OOCTXT* pctxt, H245MasterSlaveDeterminationAck_decision* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* master */
+      case 0:
+         invokeStartElement (pctxt, "master", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "master", -1);
+
+         break;
+
+      /* slave */
+      case 1:
+         invokeStartElement (pctxt, "slave", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "slave", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationAck                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationAck (OOCTXT* pctxt, H245MasterSlaveDeterminationAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode decision */
+
+   invokeStartElement (pctxt, "decision", -1);
+
+   stat = asn1PD_H245MasterSlaveDeterminationAck_decision (pctxt, &pvalue->decision);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "decision", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationReject_cause                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationReject_cause (OOCTXT* pctxt, H245MasterSlaveDeterminationReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* identicalNumbers */
+         case 0:
+            invokeStartElement (pctxt, "identicalNumbers", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "identicalNumbers", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationReject                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationReject (OOCTXT* pctxt, H245MasterSlaveDeterminationReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245MasterSlaveDeterminationReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetAck                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalCapabilitySetAck (OOCTXT* pctxt, H245TerminalCapabilitySetAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject_cause_tableEntryCapacityExce  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* highestEntryNumberProcessed */
+      case 0:
+         invokeStartElement (pctxt, "highestEntryNumberProcessed", -1);
+
+         stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->u.highestEntryNumberProcessed);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "highestEntryNumberProcessed", -1);
+
+         break;
+
+      /* noneProcessed */
+      case 1:
+         invokeStartElement (pctxt, "noneProcessed", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "noneProcessed", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject_cause                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalCapabilitySetReject_cause (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unspecified */
+         case 0:
+            invokeStartElement (pctxt, "unspecified", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unspecified", -1);
+
+            break;
+
+         /* undefinedTableEntryUsed */
+         case 1:
+            invokeStartElement (pctxt, "undefinedTableEntryUsed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedTableEntryUsed", -1);
+
+            break;
+
+         /* descriptorCapacityExceeded */
+         case 2:
+            invokeStartElement (pctxt, "descriptorCapacityExceeded", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "descriptorCapacityExceeded", -1);
+
+            break;
+
+         /* tableEntryCapacityExceeded */
+         case 3:
+            invokeStartElement (pctxt, "tableEntryCapacityExceeded", -1);
+
+            pvalue->u.tableEntryCapacityExceeded = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded);
+
+            stat = asn1PD_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (pctxt, pvalue->u.tableEntryCapacityExceeded);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "tableEntryCapacityExceeded", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalCapabilitySetReject (OOCTXT* pctxt, H245TerminalCapabilitySetReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245TerminalCapabilitySetReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_reverseLogicalChannelParameters_mu  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* h222LogicalChannelParameters */
+         case 0:
+            invokeStartElement (pctxt, "h222LogicalChannelParameters", -1);
+
+            pvalue->u.h222LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H222LogicalChannelParameters);
+
+            stat = asn1PD_H245H222LogicalChannelParameters (pctxt, pvalue->u.h222LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h222LogicalChannelParameters", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* h2250LogicalChannelParameters */
+         case 2:
+            invokeStartElement (pctxt, "h2250LogicalChannelParameters", -1);
+
+            pvalue->u.h2250LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H2250LogicalChannelParameters);
+
+            stat = asn1PD_H245H2250LogicalChannelParameters (pctxt, pvalue->u.h2250LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h2250LogicalChannelParameters", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_reverseLogicalChannelParameters     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.portNumberPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.multiplexParametersPresent = optbit;
+
+   /* decode reverseLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "reverseLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->reverseLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "reverseLogicalChannelNumber", -1);
+
+   /* decode portNumber */
+
+   if (pvalue->m.portNumberPresent) {
+      invokeStartElement (pctxt, "portNumber", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->portNumber, 0U, 65535U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->portNumber);
+
+      invokeEndElement (pctxt, "portNumber", -1);
+   }
+
+   /* decode multiplexParameters */
+
+   if (pvalue->m.multiplexParametersPresent) {
+      invokeStartElement (pctxt, "multiplexParameters", -1);
+
+      stat = asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "multiplexParameters", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.replacementForPresent = 1;
+
+                     invokeStartElement (pctxt, "replacementFor", -1);
+
+                     stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->replacementFor);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "replacementFor", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelAckParameters                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H2250LogicalChannelAckParameters (OOCTXT* pctxt, H245H2250LogicalChannelAckParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.sessionIDPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaChannelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaControlChannelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.dynamicRTPPayloadTypePresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   /* decode sessionID */
+
+   if (pvalue->m.sessionIDPresent) {
+      invokeStartElement (pctxt, "sessionID", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->sessionID, 1U, 255U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->sessionID);
+
+      invokeEndElement (pctxt, "sessionID", -1);
+   }
+
+   /* decode mediaChannel */
+
+   if (pvalue->m.mediaChannelPresent) {
+      invokeStartElement (pctxt, "mediaChannel", -1);
+
+      stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaChannel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaChannel", -1);
+   }
+
+   /* decode mediaControlChannel */
+
+   if (pvalue->m.mediaControlChannelPresent) {
+      invokeStartElement (pctxt, "mediaControlChannel", -1);
+
+      stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaControlChannel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaControlChannel", -1);
+   }
+
+   /* decode dynamicRTPPayloadType */
+
+   if (pvalue->m.dynamicRTPPayloadTypePresent) {
+      invokeStartElement (pctxt, "dynamicRTPPayloadType", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->dynamicRTPPayloadType, 96U, 127U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->dynamicRTPPayloadType);
+
+      invokeEndElement (pctxt, "dynamicRTPPayloadType", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 2 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.flowControlToZeroPresent = 1;
+
+                     invokeStartElement (pctxt, "flowControlToZero", -1);
+
+                     stat = DECODEBIT (pctxt, &pvalue->flowControlToZero);
+                     if (stat != ASN_OK) return stat;
+                     invokeBoolValue (pctxt, pvalue->flowControlToZero);
+
+                     invokeEndElement (pctxt, "flowControlToZero", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.portNumberPresent = 1;
+
+                     invokeStartElement (pctxt, "portNumber", -1);
+
+                     stat = decodeConsUInt16 (pctxt, &pvalue->portNumber, 0U, 65535U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->portNumber);
+
+                     invokeEndElement (pctxt, "portNumber", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_forwardMultiplexAckParameters       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_forwardMultiplexAckParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* h2250LogicalChannelAckParameters */
+         case 0:
+            invokeStartElement (pctxt, "h2250LogicalChannelAckParameters", -1);
+
+            pvalue->u.h2250LogicalChannelAckParameters = ALLOC_ASN1ELEM (pctxt, H245H2250LogicalChannelAckParameters);
+
+            stat = asn1PD_H245H2250LogicalChannelAckParameters (pctxt, pvalue->u.h2250LogicalChannelAckParameters);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h2250LogicalChannelAckParameters", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannelAck (OOCTXT* pctxt, H245OpenLogicalChannelAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.reverseLogicalChannelParametersPresent = optbit;
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   /* decode reverseLogicalChannelParameters */
+
+   if (pvalue->m.reverseLogicalChannelParametersPresent) {
+      invokeStartElement (pctxt, "reverseLogicalChannelParameters", -1);
+
+      stat = asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (pctxt, &pvalue->reverseLogicalChannelParameters);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "reverseLogicalChannelParameters", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 3 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.separateStackPresent = 1;
+
+                     invokeStartElement (pctxt, "separateStack", -1);
+
+                     stat = asn1PD_H245NetworkAccessParameters (pctxt, &pvalue->separateStack);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "separateStack", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.forwardMultiplexAckParametersPresent = 1;
+
+                     invokeStartElement (pctxt, "forwardMultiplexAckParameters", -1);
+
+                     stat = asn1PD_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (pctxt, &pvalue->forwardMultiplexAckParameters);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "forwardMultiplexAckParameters", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.encryptionSyncPresent = 1;
+
+                     invokeStartElement (pctxt, "encryptionSync", -1);
+
+                     stat = asn1PD_H245EncryptionSync (pctxt, &pvalue->encryptionSync);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "encryptionSync", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelReject_cause                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannelReject_cause (OOCTXT* pctxt, H245OpenLogicalChannelReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unspecified */
+         case 0:
+            invokeStartElement (pctxt, "unspecified", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unspecified", -1);
+
+            break;
+
+         /* unsuitableReverseParameters */
+         case 1:
+            invokeStartElement (pctxt, "unsuitableReverseParameters", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unsuitableReverseParameters", -1);
+
+            break;
+
+         /* dataTypeNotSupported */
+         case 2:
+            invokeStartElement (pctxt, "dataTypeNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "dataTypeNotSupported", -1);
+
+            break;
+
+         /* dataTypeNotAvailable */
+         case 3:
+            invokeStartElement (pctxt, "dataTypeNotAvailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "dataTypeNotAvailable", -1);
+
+            break;
+
+         /* unknownDataType */
+         case 4:
+            invokeStartElement (pctxt, "unknownDataType", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unknownDataType", -1);
+
+            break;
+
+         /* dataTypeALCombinationNotSupported */
+         case 5:
+            invokeStartElement (pctxt, "dataTypeALCombinationNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "dataTypeALCombinationNotSupported", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 7;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* multicastChannelNotAllowed */
+         case 7:
+            invokeStartElement (pctxt, "multicastChannelNotAllowed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "multicastChannelNotAllowed", -1);
+
+            break;
+
+         /* insufficientBandwidth */
+         case 8:
+            invokeStartElement (pctxt, "insufficientBandwidth", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "insufficientBandwidth", -1);
+
+            break;
+
+         /* separateStackEstablishmentFailed */
+         case 9:
+            invokeStartElement (pctxt, "separateStackEstablishmentFailed", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "separateStackEstablishmentFailed", -1);
+
+            break;
+
+         /* invalidSessionID */
+         case 10:
+            invokeStartElement (pctxt, "invalidSessionID", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidSessionID", -1);
+
+            break;
+
+         /* masterSlaveConflict */
+         case 11:
+            invokeStartElement (pctxt, "masterSlaveConflict", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "masterSlaveConflict", -1);
+
+            break;
+
+         /* waitForCommunicationMode */
+         case 12:
+            invokeStartElement (pctxt, "waitForCommunicationMode", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "waitForCommunicationMode", -1);
+
+            break;
+
+         /* invalidDependentChannel */
+         case 13:
+            invokeStartElement (pctxt, "invalidDependentChannel", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "invalidDependentChannel", -1);
+
+            break;
+
+         /* replacementForRejected */
+         case 14:
+            invokeStartElement (pctxt, "replacementForRejected", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "replacementForRejected", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelReject                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannelReject (OOCTXT* pctxt, H245OpenLogicalChannelReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245OpenLogicalChannelReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannelAck                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CloseLogicalChannelAck (OOCTXT* pctxt, H245CloseLogicalChannelAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseAck                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestChannelCloseAck (OOCTXT* pctxt, H245RequestChannelCloseAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseReject_cause                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestChannelCloseReject_cause (OOCTXT* pctxt, H245RequestChannelCloseReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unspecified */
+         case 0:
+            invokeStartElement (pctxt, "unspecified", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unspecified", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseReject                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestChannelCloseReject (OOCTXT* pctxt, H245RequestChannelCloseReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245RequestChannelCloseReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendAck_multiplexTableEntryNumber           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntrySendAck_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendAck_multiplexTableEntryNumber* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendAck                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntrySendAck (OOCTXT* pctxt, H245MultiplexEntrySendAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode multiplexTableEntryNumber */
+
+   invokeStartElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   stat = asn1PD_H245MultiplexEntrySendAck_multiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryRejectionDescriptions_cause                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unspecifiedCause */
+         case 0:
+            invokeStartElement (pctxt, "unspecifiedCause", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unspecifiedCause", -1);
+
+            break;
+
+         /* descriptorTooComplex */
+         case 1:
+            invokeStartElement (pctxt, "descriptorTooComplex", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "descriptorTooComplex", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryRejectionDescriptions                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode multiplexTableEntryNumber */
+
+   invokeStartElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245MultiplexEntryRejectionDescriptions_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendReject_rejectionDescriptions            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntrySendReject_rejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntrySendReject_rejectionDescriptions* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   H245MultiplexEntryRejectionDescriptions* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245MultiplexEntryRejectionDescriptions);
+
+      stat = asn1PD_H245MultiplexEntryRejectionDescriptions (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendReject                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntrySendReject (OOCTXT* pctxt, H245MultiplexEntrySendReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode rejectionDescriptions */
+
+   invokeStartElement (pctxt, "rejectionDescriptions", -1);
+
+   stat = asn1PD_H245MultiplexEntrySendReject_rejectionDescriptions (pctxt, &pvalue->rejectionDescriptions);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectionDescriptions", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryAck_entryNumbers                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryAck_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryAck_entryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryAck                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryAck (OOCTXT* pctxt, H245RequestMultiplexEntryAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode entryNumbers */
+
+   invokeStartElement (pctxt, "entryNumbers", -1);
+
+   stat = asn1PD_H245RequestMultiplexEntryAck_entryNumbers (pctxt, &pvalue->entryNumbers);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "entryNumbers", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject_entryNumbers                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryReject_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryReject_entryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRejectionDescriptions_cause          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unspecifiedCause */
+         case 0:
+            invokeStartElement (pctxt, "unspecifiedCause", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unspecifiedCause", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRejectionDescriptions                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode multiplexTableEntryNumber */
+
+   invokeStartElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245RequestMultiplexEntryRejectionDescriptions_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject_rejectionDescriptions         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryReject_rejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryReject_rejectionDescriptions* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   H245RequestMultiplexEntryRejectionDescriptions* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245RequestMultiplexEntryRejectionDescriptions);
+
+      stat = asn1PD_H245RequestMultiplexEntryRejectionDescriptions (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryReject (OOCTXT* pctxt, H245RequestMultiplexEntryReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode entryNumbers */
+
+   invokeStartElement (pctxt, "entryNumbers", -1);
+
+   stat = asn1PD_H245RequestMultiplexEntryReject_entryNumbers (pctxt, &pvalue->entryNumbers);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "entryNumbers", -1);
+
+   /* decode rejectionDescriptions */
+
+   invokeStartElement (pctxt, "rejectionDescriptions", -1);
+
+   stat = asn1PD_H245RequestMultiplexEntryReject_rejectionDescriptions (pctxt, &pvalue->rejectionDescriptions);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectionDescriptions", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeAck_response                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestModeAck_response (OOCTXT* pctxt, H245RequestModeAck_response* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* willTransmitMostPreferredMode */
+         case 0:
+            invokeStartElement (pctxt, "willTransmitMostPreferredMode", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "willTransmitMostPreferredMode", -1);
+
+            break;
+
+         /* willTransmitLessPreferredMode */
+         case 1:
+            invokeStartElement (pctxt, "willTransmitLessPreferredMode", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "willTransmitLessPreferredMode", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeAck                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestModeAck (OOCTXT* pctxt, H245RequestModeAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode response */
+
+   invokeStartElement (pctxt, "response", -1);
+
+   stat = asn1PD_H245RequestModeAck_response (pctxt, &pvalue->response);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "response", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeReject_cause                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestModeReject_cause (OOCTXT* pctxt, H245RequestModeReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* modeUnavailable */
+         case 0:
+            invokeStartElement (pctxt, "modeUnavailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "modeUnavailable", -1);
+
+            break;
+
+         /* multipointConstraint */
+         case 1:
+            invokeStartElement (pctxt, "multipointConstraint", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "multipointConstraint", -1);
+
+            break;
+
+         /* requestDenied */
+         case 2:
+            invokeStartElement (pctxt, "requestDenied", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "requestDenied", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeReject                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestModeReject (OOCTXT* pctxt, H245RequestModeReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245RequestModeReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RoundTripDelayResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RoundTripDelayResponse (OOCTXT* pctxt, H245RoundTripDelayResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopAck_type                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaintenanceLoopAck_type (OOCTXT* pctxt, H245MaintenanceLoopAck_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* systemLoop */
+         case 0:
+            invokeStartElement (pctxt, "systemLoop", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "systemLoop", -1);
+
+            break;
+
+         /* mediaLoop */
+         case 1:
+            invokeStartElement (pctxt, "mediaLoop", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.mediaLoop);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "mediaLoop", -1);
+
+            break;
+
+         /* logicalChannelLoop */
+         case 2:
+            invokeStartElement (pctxt, "logicalChannelLoop", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelLoop);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "logicalChannelLoop", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopAck                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaintenanceLoopAck (OOCTXT* pctxt, H245MaintenanceLoopAck* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245MaintenanceLoopAck_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject_type                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaintenanceLoopReject_type (OOCTXT* pctxt, H245MaintenanceLoopReject_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* systemLoop */
+         case 0:
+            invokeStartElement (pctxt, "systemLoop", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "systemLoop", -1);
+
+            break;
+
+         /* mediaLoop */
+         case 1:
+            invokeStartElement (pctxt, "mediaLoop", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.mediaLoop);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "mediaLoop", -1);
+
+            break;
+
+         /* logicalChannelLoop */
+         case 2:
+            invokeStartElement (pctxt, "logicalChannelLoop", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelLoop);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "logicalChannelLoop", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject_cause                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaintenanceLoopReject_cause (OOCTXT* pctxt, H245MaintenanceLoopReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* canNotPerformLoop */
+         case 0:
+            invokeStartElement (pctxt, "canNotPerformLoop", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "canNotPerformLoop", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaintenanceLoopReject (OOCTXT* pctxt, H245MaintenanceLoopReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245MaintenanceLoopReject_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245MaintenanceLoopReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeTableEntry_dataType                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CommunicationModeTableEntry_dataType (OOCTXT* pctxt, H245CommunicationModeTableEntry_dataType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* videoData */
+         case 0:
+            invokeStartElement (pctxt, "videoData", -1);
+
+            pvalue->u.videoData = ALLOC_ASN1ELEM (pctxt, H245VideoCapability);
+
+            stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.videoData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoData", -1);
+
+            break;
+
+         /* audioData */
+         case 1:
+            invokeStartElement (pctxt, "audioData", -1);
+
+            pvalue->u.audioData = ALLOC_ASN1ELEM (pctxt, H245AudioCapability);
+
+            stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.audioData);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "audioData", -1);
+
+            break;
+
+         /* data */
+         case 2:
+            invokeStartElement (pctxt, "data", -1);
+
+            pvalue->u.data = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability);
+
+            stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.data);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "data", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeTableEntry                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CommunicationModeTableEntry (OOCTXT* pctxt, H245CommunicationModeTableEntry* pvalue)
+{
+   static Asn1SizeCnst sessionDescription_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.nonStandardPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.associatedSessionIDPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalLabelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaChannelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaGuaranteedDeliveryPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaControlChannelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.mediaControlGuaranteedDeliveryPresent = optbit;
+
+   /* decode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      invokeStartElement (pctxt, "nonStandard", -1);
+
+      stat = asn1PD_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "nonStandard", -1);
+   }
+
+   /* decode sessionID */
+
+   invokeStartElement (pctxt, "sessionID", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sessionID, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sessionID);
+
+   invokeEndElement (pctxt, "sessionID", -1);
+
+   /* decode associatedSessionID */
+
+   if (pvalue->m.associatedSessionIDPresent) {
+      invokeStartElement (pctxt, "associatedSessionID", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->associatedSessionID, 1U, 255U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->associatedSessionID);
+
+      invokeEndElement (pctxt, "associatedSessionID", -1);
+   }
+
+   /* decode terminalLabel */
+
+   if (pvalue->m.terminalLabelPresent) {
+      invokeStartElement (pctxt, "terminalLabel", -1);
+
+      stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminalLabel", -1);
+   }
+
+   /* decode sessionDescription */
+
+   invokeStartElement (pctxt, "sessionDescription", -1);
+
+   addSizeConstraint (pctxt, &sessionDescription_lsize1);
+
+   stat = decodeBMPString (pctxt, &pvalue->sessionDescription, 0);
+   if (stat != ASN_OK) return stat;
+   invokeCharStr16BitValue (pctxt, pvalue->sessionDescription.nchars, pvalue->sessionDescription.data);
+
+   invokeEndElement (pctxt, "sessionDescription", -1);
+
+   /* decode dataType */
+
+   invokeStartElement (pctxt, "dataType", -1);
+
+   stat = asn1PD_H245CommunicationModeTableEntry_dataType (pctxt, &pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "dataType", -1);
+
+   /* decode mediaChannel */
+
+   if (pvalue->m.mediaChannelPresent) {
+      invokeStartElement (pctxt, "mediaChannel", -1);
+
+      stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaChannel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaChannel", -1);
+   }
+
+   /* decode mediaGuaranteedDelivery */
+
+   if (pvalue->m.mediaGuaranteedDeliveryPresent) {
+      invokeStartElement (pctxt, "mediaGuaranteedDelivery", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->mediaGuaranteedDelivery);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->mediaGuaranteedDelivery);
+
+      invokeEndElement (pctxt, "mediaGuaranteedDelivery", -1);
+   }
+
+   /* decode mediaControlChannel */
+
+   if (pvalue->m.mediaControlChannelPresent) {
+      invokeStartElement (pctxt, "mediaControlChannel", -1);
+
+      stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaControlChannel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "mediaControlChannel", -1);
+   }
+
+   /* decode mediaControlGuaranteedDelivery */
+
+   if (pvalue->m.mediaControlGuaranteedDeliveryPresent) {
+      invokeStartElement (pctxt, "mediaControlGuaranteedDelivery", -1);
+
+      stat = DECODEBIT (pctxt, &pvalue->mediaControlGuaranteedDelivery);
+      if (stat != ASN_OK) return stat;
+      invokeBoolValue (pctxt, pvalue->mediaControlGuaranteedDelivery);
+
+      invokeEndElement (pctxt, "mediaControlGuaranteedDelivery", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 3 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.redundancyEncodingPresent = 1;
+
+                     invokeStartElement (pctxt, "redundancyEncoding", -1);
+
+                     stat = asn1PD_H245RedundancyEncoding (pctxt, &pvalue->redundancyEncoding);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "redundancyEncoding", -1);
+                     break;
+
+                  case 1:
+                     pvalue->m.sessionDependencyPresent = 1;
+
+                     invokeStartElement (pctxt, "sessionDependency", -1);
+
+                     stat = decodeConsUInt8 (pctxt, &pvalue->sessionDependency, 1U, 255U);
+                     if (stat != ASN_OK) return stat;
+                     invokeUIntValue (pctxt, pvalue->sessionDependency);
+
+                     invokeEndElement (pctxt, "sessionDependency", -1);
+                     break;
+
+                  case 2:
+                     pvalue->m.destinationPresent = 1;
+
+                     invokeStartElement (pctxt, "destination", -1);
+
+                     stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->destination);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "destination", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeResponse_communicationModeTable          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CommunicationModeResponse_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeResponse_communicationModeTable* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245CommunicationModeTableEntry* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245CommunicationModeTableEntry);
+
+      stat = asn1PD_H245CommunicationModeTableEntry (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeResponse                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CommunicationModeResponse (OOCTXT* pctxt, H245CommunicationModeResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* communicationModeTable */
+         case 0:
+            invokeStartElement (pctxt, "communicationModeTable", -1);
+
+            pvalue->u.communicationModeTable = ALLOC_ASN1ELEM (pctxt, H245CommunicationModeResponse_communicationModeTable);
+
+            stat = asn1PD_H245CommunicationModeResponse_communicationModeTable (pctxt, pvalue->u.communicationModeTable);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "communicationModeTable", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 2;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalID                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalID (OOCTXT* pctxt, H245TerminalID* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_mCTerminalIDResponse                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_mCTerminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_mCTerminalIDResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalLabel */
+
+   invokeStartElement (pctxt, "terminalLabel", -1);
+
+   stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalLabel", -1);
+
+   /* decode terminalID */
+
+   invokeStartElement (pctxt, "terminalID", -1);
+
+   stat = asn1PD_H245TerminalID (pctxt, &pvalue->terminalID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalID", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalIDResponse                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_terminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalIDResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalLabel */
+
+   invokeStartElement (pctxt, "terminalLabel", -1);
+
+   stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalLabel", -1);
+
+   /* decode terminalID */
+
+   invokeStartElement (pctxt, "terminalID", -1);
+
+   stat = asn1PD_H245TerminalID (pctxt, &pvalue->terminalID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalID", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceID                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceID (OOCTXT* pctxt, H245ConferenceID* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_conferenceIDResponse                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_conferenceIDResponse (OOCTXT* pctxt, H245ConferenceResponse_conferenceIDResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalLabel */
+
+   invokeStartElement (pctxt, "terminalLabel", -1);
+
+   stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalLabel", -1);
+
+   /* decode conferenceID */
+
+   invokeStartElement (pctxt, "conferenceID", -1);
+
+   stat = asn1PD_H245ConferenceID (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceID", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Password                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245Password (OOCTXT* pctxt, H245Password* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_passwordResponse                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_passwordResponse (OOCTXT* pctxt, H245ConferenceResponse_passwordResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalLabel */
+
+   invokeStartElement (pctxt, "terminalLabel", -1);
+
+   stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalLabel", -1);
+
+   /* decode password */
+
+   invokeStartElement (pctxt, "password", -1);
+
+   stat = asn1PD_H245Password (pctxt, &pvalue->password);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "password", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalListResponse                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_terminalListResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalListResponse* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245TerminalLabel* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245TerminalLabel);
+
+      stat = asn1PD_H245TerminalLabel (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_makeMeChairResponse                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_makeMeChairResponse (OOCTXT* pctxt, H245ConferenceResponse_makeMeChairResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* grantedChairToken */
+         case 0:
+            invokeStartElement (pctxt, "grantedChairToken", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "grantedChairToken", -1);
+
+            break;
+
+         /* deniedChairToken */
+         case 1:
+            invokeStartElement (pctxt, "deniedChairToken", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "deniedChairToken", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_extensionAddressResponse               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_extensionAddressResponse (OOCTXT* pctxt, H245ConferenceResponse_extensionAddressResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode extensionAddress */
+
+   invokeStartElement (pctxt, "extensionAddress", -1);
+
+   stat = asn1PD_H245TerminalID (pctxt, &pvalue->extensionAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "extensionAddress", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_chairTokenOwnerResponse                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_chairTokenOwnerResponse (OOCTXT* pctxt, H245ConferenceResponse_chairTokenOwnerResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalLabel */
+
+   invokeStartElement (pctxt, "terminalLabel", -1);
+
+   stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalLabel", -1);
+
+   /* decode terminalID */
+
+   invokeStartElement (pctxt, "terminalID", -1);
+
+   stat = asn1PD_H245TerminalID (pctxt, &pvalue->terminalID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalID", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalCertificateResponse            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_terminalCertificateResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalCertificateResponse* pvalue)
+{
+   static Asn1SizeCnst certificateResponse_lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.terminalLabelPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.certificateResponsePresent = optbit;
+
+   /* decode terminalLabel */
+
+   if (pvalue->m.terminalLabelPresent) {
+      invokeStartElement (pctxt, "terminalLabel", -1);
+
+      stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "terminalLabel", -1);
+   }
+
+   /* decode certificateResponse */
+
+   if (pvalue->m.certificateResponsePresent) {
+      invokeStartElement (pctxt, "certificateResponse", -1);
+
+      addSizeConstraint (pctxt, &certificateResponse_lsize1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->certificateResponse);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->certificateResponse.numocts, pvalue->certificateResponse.data);
+
+      invokeEndElement (pctxt, "certificateResponse", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_broadcastMyLogicalChannelResponse      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_broadcastMyLogicalChannelResponse (OOCTXT* pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* grantedBroadcastMyLogicalChannel */
+         case 0:
+            invokeStartElement (pctxt, "grantedBroadcastMyLogicalChannel", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "grantedBroadcastMyLogicalChannel", -1);
+
+            break;
+
+         /* deniedBroadcastMyLogicalChannel */
+         case 1:
+            invokeStartElement (pctxt, "deniedBroadcastMyLogicalChannel", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "deniedBroadcastMyLogicalChannel", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_makeTerminalBroadcasterResponse        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_makeTerminalBroadcasterResponse (OOCTXT* pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* grantedMakeTerminalBroadcaster */
+         case 0:
+            invokeStartElement (pctxt, "grantedMakeTerminalBroadcaster", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "grantedMakeTerminalBroadcaster", -1);
+
+            break;
+
+         /* deniedMakeTerminalBroadcaster */
+         case 1:
+            invokeStartElement (pctxt, "deniedMakeTerminalBroadcaster", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "deniedMakeTerminalBroadcaster", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_sendThisSourceResponse                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse_sendThisSourceResponse (OOCTXT* pctxt, H245ConferenceResponse_sendThisSourceResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* grantedSendThisSource */
+         case 0:
+            invokeStartElement (pctxt, "grantedSendThisSource", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "grantedSendThisSource", -1);
+
+            break;
+
+         /* deniedSendThisSource */
+         case 1:
+            invokeStartElement (pctxt, "deniedSendThisSource", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "deniedSendThisSource", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalInformation                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalInformation (OOCTXT* pctxt, H245TerminalInformation* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalLabel */
+
+   invokeStartElement (pctxt, "terminalLabel", -1);
+
+   stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalLabel", -1);
+
+   /* decode terminalID */
+
+   invokeStartElement (pctxt, "terminalID", -1);
+
+   stat = asn1PD_H245TerminalID (pctxt, &pvalue->terminalID);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalID", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245TerminalInformation                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245TerminalInformation (OOCTXT* pctxt, H245_SeqOfH245TerminalInformation* pvalue)
+{
+   int stat = ASN_OK;
+   H245TerminalInformation* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245TerminalInformation);
+
+         stat = asn1PD_H245TerminalInformation (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestAllTerminalIDsResponse                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestAllTerminalIDsResponse (OOCTXT* pctxt, H245RequestAllTerminalIDsResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalInformation */
+
+   invokeStartElement (pctxt, "terminalInformation", -1);
+
+   stat = asn1PD_H245_SeqOfH245TerminalInformation (pctxt, &pvalue->terminalInformation);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalInformation", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCResponse_reject                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RemoteMCResponse_reject (OOCTXT* pctxt, H245RemoteMCResponse_reject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* unspecified */
+         case 0:
+            invokeStartElement (pctxt, "unspecified", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unspecified", -1);
+
+            break;
+
+         /* functionNotSupported */
+         case 1:
+            invokeStartElement (pctxt, "functionNotSupported", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "functionNotSupported", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCResponse                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RemoteMCResponse (OOCTXT* pctxt, H245RemoteMCResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* accept */
+         case 0:
+            invokeStartElement (pctxt, "accept", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "accept", -1);
+
+            break;
+
+         /* reject */
+         case 1:
+            invokeStartElement (pctxt, "reject", -1);
+
+            pvalue->u.reject = ALLOC_ASN1ELEM (pctxt, H245RemoteMCResponse_reject);
+
+            stat = asn1PD_H245RemoteMCResponse_reject (pctxt, pvalue->u.reject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "reject", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceResponse (OOCTXT* pctxt, H245ConferenceResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* mCTerminalIDResponse */
+         case 0:
+            invokeStartElement (pctxt, "mCTerminalIDResponse", -1);
+
+            pvalue->u.mCTerminalIDResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_mCTerminalIDResponse);
+
+            stat = asn1PD_H245ConferenceResponse_mCTerminalIDResponse (pctxt, pvalue->u.mCTerminalIDResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "mCTerminalIDResponse", -1);
+
+            break;
+
+         /* terminalIDResponse */
+         case 1:
+            invokeStartElement (pctxt, "terminalIDResponse", -1);
+
+            pvalue->u.terminalIDResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_terminalIDResponse);
+
+            stat = asn1PD_H245ConferenceResponse_terminalIDResponse (pctxt, pvalue->u.terminalIDResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalIDResponse", -1);
+
+            break;
+
+         /* conferenceIDResponse */
+         case 2:
+            invokeStartElement (pctxt, "conferenceIDResponse", -1);
+
+            pvalue->u.conferenceIDResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_conferenceIDResponse);
+
+            stat = asn1PD_H245ConferenceResponse_conferenceIDResponse (pctxt, pvalue->u.conferenceIDResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "conferenceIDResponse", -1);
+
+            break;
+
+         /* passwordResponse */
+         case 3:
+            invokeStartElement (pctxt, "passwordResponse", -1);
+
+            pvalue->u.passwordResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_passwordResponse);
+
+            stat = asn1PD_H245ConferenceResponse_passwordResponse (pctxt, pvalue->u.passwordResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "passwordResponse", -1);
+
+            break;
+
+         /* terminalListResponse */
+         case 4:
+            invokeStartElement (pctxt, "terminalListResponse", -1);
+
+            pvalue->u.terminalListResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_terminalListResponse);
+
+            stat = asn1PD_H245ConferenceResponse_terminalListResponse (pctxt, pvalue->u.terminalListResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalListResponse", -1);
+
+            break;
+
+         /* videoCommandReject */
+         case 5:
+            invokeStartElement (pctxt, "videoCommandReject", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "videoCommandReject", -1);
+
+            break;
+
+         /* terminalDropReject */
+         case 6:
+            invokeStartElement (pctxt, "terminalDropReject", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "terminalDropReject", -1);
+
+            break;
+
+         /* makeMeChairResponse */
+         case 7:
+            invokeStartElement (pctxt, "makeMeChairResponse", -1);
+
+            pvalue->u.makeMeChairResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_makeMeChairResponse);
+
+            stat = asn1PD_H245ConferenceResponse_makeMeChairResponse (pctxt, pvalue->u.makeMeChairResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "makeMeChairResponse", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 9;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* extensionAddressResponse */
+         case 9:
+            invokeStartElement (pctxt, "extensionAddressResponse", -1);
+
+            pvalue->u.extensionAddressResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_extensionAddressResponse);
+
+            stat = asn1PD_H245ConferenceResponse_extensionAddressResponse (pctxt, pvalue->u.extensionAddressResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "extensionAddressResponse", -1);
+
+            break;
+
+         /* chairTokenOwnerResponse */
+         case 10:
+            invokeStartElement (pctxt, "chairTokenOwnerResponse", -1);
+
+            pvalue->u.chairTokenOwnerResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_chairTokenOwnerResponse);
+
+            stat = asn1PD_H245ConferenceResponse_chairTokenOwnerResponse (pctxt, pvalue->u.chairTokenOwnerResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "chairTokenOwnerResponse", -1);
+
+            break;
+
+         /* terminalCertificateResponse */
+         case 11:
+            invokeStartElement (pctxt, "terminalCertificateResponse", -1);
+
+            pvalue->u.terminalCertificateResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_terminalCertificateResponse);
+
+            stat = asn1PD_H245ConferenceResponse_terminalCertificateResponse (pctxt, pvalue->u.terminalCertificateResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalCertificateResponse", -1);
+
+            break;
+
+         /* broadcastMyLogicalChannelResponse */
+         case 12:
+            invokeStartElement (pctxt, "broadcastMyLogicalChannelResponse", -1);
+
+            pvalue->u.broadcastMyLogicalChannelResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse);
+
+            stat = asn1PD_H245ConferenceResponse_broadcastMyLogicalChannelResponse (pctxt, pvalue->u.broadcastMyLogicalChannelResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "broadcastMyLogicalChannelResponse", -1);
+
+            break;
+
+         /* makeTerminalBroadcasterResponse */
+         case 13:
+            invokeStartElement (pctxt, "makeTerminalBroadcasterResponse", -1);
+
+            pvalue->u.makeTerminalBroadcasterResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse);
+
+            stat = asn1PD_H245ConferenceResponse_makeTerminalBroadcasterResponse (pctxt, pvalue->u.makeTerminalBroadcasterResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "makeTerminalBroadcasterResponse", -1);
+
+            break;
+
+         /* sendThisSourceResponse */
+         case 14:
+            invokeStartElement (pctxt, "sendThisSourceResponse", -1);
+
+            pvalue->u.sendThisSourceResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_sendThisSourceResponse);
+
+            stat = asn1PD_H245ConferenceResponse_sendThisSourceResponse (pctxt, pvalue->u.sendThisSourceResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "sendThisSourceResponse", -1);
+
+            break;
+
+         /* requestAllTerminalIDsResponse */
+         case 15:
+            invokeStartElement (pctxt, "requestAllTerminalIDsResponse", -1);
+
+            pvalue->u.requestAllTerminalIDsResponse = ALLOC_ASN1ELEM (pctxt, H245RequestAllTerminalIDsResponse);
+
+            stat = asn1PD_H245RequestAllTerminalIDsResponse (pctxt, pvalue->u.requestAllTerminalIDsResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestAllTerminalIDsResponse", -1);
+
+            break;
+
+         /* remoteMCResponse */
+         case 16:
+            invokeStartElement (pctxt, "remoteMCResponse", -1);
+
+            pvalue->u.remoteMCResponse = ALLOC_ASN1ELEM (pctxt, H245RemoteMCResponse);
+
+            stat = asn1PD_H245RemoteMCResponse (pctxt, pvalue->u.remoteMCResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "remoteMCResponse", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_callInformation                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkResponse_callInformation (OOCTXT* pctxt, H245MultilinkResponse_callInformation* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode dialingInformation */
+
+   invokeStartElement (pctxt, "dialingInformation", -1);
+
+   stat = asn1PD_H245DialingInformation (pctxt, &pvalue->dialingInformation);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "dialingInformation", -1);
+
+   /* decode callAssociationNumber */
+
+   invokeStartElement (pctxt, "callAssociationNumber", -1);
+
+   stat = decodeConsUnsigned (pctxt, &pvalue->callAssociationNumber, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->callAssociationNumber);
+
+   invokeEndElement (pctxt, "callAssociationNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection_responseCode_rejected     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkResponse_addConnection_responseCode_rejected (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode_rejected* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* connectionsNotAvailable */
+         case 0:
+            invokeStartElement (pctxt, "connectionsNotAvailable", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "connectionsNotAvailable", -1);
+
+            break;
+
+         /* userRejected */
+         case 1:
+            invokeStartElement (pctxt, "userRejected", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "userRejected", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection_responseCode              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkResponse_addConnection_responseCode (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* accepted */
+         case 0:
+            invokeStartElement (pctxt, "accepted", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "accepted", -1);
+
+            break;
+
+         /* rejected */
+         case 1:
+            invokeStartElement (pctxt, "rejected", -1);
+
+            pvalue->u.rejected = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_addConnection_responseCode_rejected);
+
+            stat = asn1PD_H245MultilinkResponse_addConnection_responseCode_rejected (pctxt, pvalue->u.rejected);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "rejected", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkResponse_addConnection (OOCTXT* pctxt, H245MultilinkResponse_addConnection* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode responseCode */
+
+   invokeStartElement (pctxt, "responseCode", -1);
+
+   stat = asn1PD_H245MultilinkResponse_addConnection_responseCode (pctxt, &pvalue->responseCode);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "responseCode", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_removeConnection                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkResponse_removeConnection (OOCTXT* pctxt, H245MultilinkResponse_removeConnection* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode connectionIdentifier */
+
+   invokeStartElement (pctxt, "connectionIdentifier", -1);
+
+   stat = asn1PD_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "connectionIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_maximumHeaderInterval                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkResponse_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkResponse_maximumHeaderInterval* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode currentInterval */
+
+   invokeStartElement (pctxt, "currentInterval", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->currentInterval, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->currentInterval);
+
+   invokeEndElement (pctxt, "currentInterval", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkResponse (OOCTXT* pctxt, H245MultilinkResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* callInformation */
+         case 1:
+            invokeStartElement (pctxt, "callInformation", -1);
+
+            pvalue->u.callInformation = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_callInformation);
+
+            stat = asn1PD_H245MultilinkResponse_callInformation (pctxt, pvalue->u.callInformation);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "callInformation", -1);
+
+            break;
+
+         /* addConnection */
+         case 2:
+            invokeStartElement (pctxt, "addConnection", -1);
+
+            pvalue->u.addConnection = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_addConnection);
+
+            stat = asn1PD_H245MultilinkResponse_addConnection (pctxt, pvalue->u.addConnection);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "addConnection", -1);
+
+            break;
+
+         /* removeConnection */
+         case 3:
+            invokeStartElement (pctxt, "removeConnection", -1);
+
+            pvalue->u.removeConnection = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_removeConnection);
+
+            stat = asn1PD_H245MultilinkResponse_removeConnection (pctxt, pvalue->u.removeConnection);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "removeConnection", -1);
+
+            break;
+
+         /* maximumHeaderInterval */
+         case 4:
+            invokeStartElement (pctxt, "maximumHeaderInterval", -1);
+
+            pvalue->u.maximumHeaderInterval = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_maximumHeaderInterval);
+
+            stat = asn1PD_H245MultilinkResponse_maximumHeaderInterval (pctxt, pvalue->u.maximumHeaderInterval);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "maximumHeaderInterval", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateAcknowledge                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245LogicalChannelRateAcknowledge (OOCTXT* pctxt, H245LogicalChannelRateAcknowledge* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode logicalChannelNumber */
+
+   invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+   /* decode maximumBitRate */
+
+   invokeStartElement (pctxt, "maximumBitRate", -1);
+
+   stat = asn1PD_H245MaximumBitRate (pctxt, &pvalue->maximumBitRate);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "maximumBitRate", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRejectReason                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245LogicalChannelRateRejectReason (OOCTXT* pctxt, H245LogicalChannelRateRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* undefinedReason */
+         case 0:
+            invokeStartElement (pctxt, "undefinedReason", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "undefinedReason", -1);
+
+            break;
+
+         /* insufficientResources */
+         case 1:
+            invokeStartElement (pctxt, "insufficientResources", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "insufficientResources", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateReject                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245LogicalChannelRateReject (OOCTXT* pctxt, H245LogicalChannelRateReject* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.currentMaximumBitRatePresent = optbit;
+
+   /* decode sequenceNumber */
+
+   invokeStartElement (pctxt, "sequenceNumber", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "sequenceNumber", -1);
+
+   /* decode logicalChannelNumber */
+
+   invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+   /* decode rejectReason */
+
+   invokeStartElement (pctxt, "rejectReason", -1);
+
+   stat = asn1PD_H245LogicalChannelRateRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "rejectReason", -1);
+
+   /* decode currentMaximumBitRate */
+
+   if (pvalue->m.currentMaximumBitRatePresent) {
+      invokeStartElement (pctxt, "currentMaximumBitRate", -1);
+
+      stat = asn1PD_H245MaximumBitRate (pctxt, &pvalue->currentMaximumBitRate);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "currentMaximumBitRate", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ResponseMessage                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ResponseMessage (OOCTXT* pctxt, H245ResponseMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 18);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* masterSlaveDeterminationAck */
+         case 1:
+            invokeStartElement (pctxt, "masterSlaveDeterminationAck", -1);
+
+            pvalue->u.masterSlaveDeterminationAck = ALLOC_ASN1ELEM (pctxt, H245MasterSlaveDeterminationAck);
+
+            stat = asn1PD_H245MasterSlaveDeterminationAck (pctxt, pvalue->u.masterSlaveDeterminationAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "masterSlaveDeterminationAck", -1);
+
+            break;
+
+         /* masterSlaveDeterminationReject */
+         case 2:
+            invokeStartElement (pctxt, "masterSlaveDeterminationReject", -1);
+
+            pvalue->u.masterSlaveDeterminationReject = ALLOC_ASN1ELEM (pctxt, H245MasterSlaveDeterminationReject);
+
+            stat = asn1PD_H245MasterSlaveDeterminationReject (pctxt, pvalue->u.masterSlaveDeterminationReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "masterSlaveDeterminationReject", -1);
+
+            break;
+
+         /* terminalCapabilitySetAck */
+         case 3:
+            invokeStartElement (pctxt, "terminalCapabilitySetAck", -1);
+
+            pvalue->u.terminalCapabilitySetAck = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySetAck);
+
+            stat = asn1PD_H245TerminalCapabilitySetAck (pctxt, pvalue->u.terminalCapabilitySetAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalCapabilitySetAck", -1);
+
+            break;
+
+         /* terminalCapabilitySetReject */
+         case 4:
+            invokeStartElement (pctxt, "terminalCapabilitySetReject", -1);
+
+            pvalue->u.terminalCapabilitySetReject = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySetReject);
+
+            stat = asn1PD_H245TerminalCapabilitySetReject (pctxt, pvalue->u.terminalCapabilitySetReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalCapabilitySetReject", -1);
+
+            break;
+
+         /* openLogicalChannelAck */
+         case 5:
+            invokeStartElement (pctxt, "openLogicalChannelAck", -1);
+
+            pvalue->u.openLogicalChannelAck = ALLOC_ASN1ELEM (pctxt, H245OpenLogicalChannelAck);
+
+            stat = asn1PD_H245OpenLogicalChannelAck (pctxt, pvalue->u.openLogicalChannelAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "openLogicalChannelAck", -1);
+
+            break;
+
+         /* openLogicalChannelReject */
+         case 6:
+            invokeStartElement (pctxt, "openLogicalChannelReject", -1);
+
+            pvalue->u.openLogicalChannelReject = ALLOC_ASN1ELEM (pctxt, H245OpenLogicalChannelReject);
+
+            stat = asn1PD_H245OpenLogicalChannelReject (pctxt, pvalue->u.openLogicalChannelReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "openLogicalChannelReject", -1);
+
+            break;
+
+         /* closeLogicalChannelAck */
+         case 7:
+            invokeStartElement (pctxt, "closeLogicalChannelAck", -1);
+
+            pvalue->u.closeLogicalChannelAck = ALLOC_ASN1ELEM (pctxt, H245CloseLogicalChannelAck);
+
+            stat = asn1PD_H245CloseLogicalChannelAck (pctxt, pvalue->u.closeLogicalChannelAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "closeLogicalChannelAck", -1);
+
+            break;
+
+         /* requestChannelCloseAck */
+         case 8:
+            invokeStartElement (pctxt, "requestChannelCloseAck", -1);
+
+            pvalue->u.requestChannelCloseAck = ALLOC_ASN1ELEM (pctxt, H245RequestChannelCloseAck);
+
+            stat = asn1PD_H245RequestChannelCloseAck (pctxt, pvalue->u.requestChannelCloseAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestChannelCloseAck", -1);
+
+            break;
+
+         /* requestChannelCloseReject */
+         case 9:
+            invokeStartElement (pctxt, "requestChannelCloseReject", -1);
+
+            pvalue->u.requestChannelCloseReject = ALLOC_ASN1ELEM (pctxt, H245RequestChannelCloseReject);
+
+            stat = asn1PD_H245RequestChannelCloseReject (pctxt, pvalue->u.requestChannelCloseReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestChannelCloseReject", -1);
+
+            break;
+
+         /* multiplexEntrySendAck */
+         case 10:
+            invokeStartElement (pctxt, "multiplexEntrySendAck", -1);
+
+            pvalue->u.multiplexEntrySendAck = ALLOC_ASN1ELEM (pctxt, H245MultiplexEntrySendAck);
+
+            stat = asn1PD_H245MultiplexEntrySendAck (pctxt, pvalue->u.multiplexEntrySendAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplexEntrySendAck", -1);
+
+            break;
+
+         /* multiplexEntrySendReject */
+         case 11:
+            invokeStartElement (pctxt, "multiplexEntrySendReject", -1);
+
+            pvalue->u.multiplexEntrySendReject = ALLOC_ASN1ELEM (pctxt, H245MultiplexEntrySendReject);
+
+            stat = asn1PD_H245MultiplexEntrySendReject (pctxt, pvalue->u.multiplexEntrySendReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplexEntrySendReject", -1);
+
+            break;
+
+         /* requestMultiplexEntryAck */
+         case 12:
+            invokeStartElement (pctxt, "requestMultiplexEntryAck", -1);
+
+            pvalue->u.requestMultiplexEntryAck = ALLOC_ASN1ELEM (pctxt, H245RequestMultiplexEntryAck);
+
+            stat = asn1PD_H245RequestMultiplexEntryAck (pctxt, pvalue->u.requestMultiplexEntryAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestMultiplexEntryAck", -1);
+
+            break;
+
+         /* requestMultiplexEntryReject */
+         case 13:
+            invokeStartElement (pctxt, "requestMultiplexEntryReject", -1);
+
+            pvalue->u.requestMultiplexEntryReject = ALLOC_ASN1ELEM (pctxt, H245RequestMultiplexEntryReject);
+
+            stat = asn1PD_H245RequestMultiplexEntryReject (pctxt, pvalue->u.requestMultiplexEntryReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestMultiplexEntryReject", -1);
+
+            break;
+
+         /* requestModeAck */
+         case 14:
+            invokeStartElement (pctxt, "requestModeAck", -1);
+
+            pvalue->u.requestModeAck = ALLOC_ASN1ELEM (pctxt, H245RequestModeAck);
+
+            stat = asn1PD_H245RequestModeAck (pctxt, pvalue->u.requestModeAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestModeAck", -1);
+
+            break;
+
+         /* requestModeReject */
+         case 15:
+            invokeStartElement (pctxt, "requestModeReject", -1);
+
+            pvalue->u.requestModeReject = ALLOC_ASN1ELEM (pctxt, H245RequestModeReject);
+
+            stat = asn1PD_H245RequestModeReject (pctxt, pvalue->u.requestModeReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestModeReject", -1);
+
+            break;
+
+         /* roundTripDelayResponse */
+         case 16:
+            invokeStartElement (pctxt, "roundTripDelayResponse", -1);
+
+            pvalue->u.roundTripDelayResponse = ALLOC_ASN1ELEM (pctxt, H245RoundTripDelayResponse);
+
+            stat = asn1PD_H245RoundTripDelayResponse (pctxt, pvalue->u.roundTripDelayResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "roundTripDelayResponse", -1);
+
+            break;
+
+         /* maintenanceLoopAck */
+         case 17:
+            invokeStartElement (pctxt, "maintenanceLoopAck", -1);
+
+            pvalue->u.maintenanceLoopAck = ALLOC_ASN1ELEM (pctxt, H245MaintenanceLoopAck);
+
+            stat = asn1PD_H245MaintenanceLoopAck (pctxt, pvalue->u.maintenanceLoopAck);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "maintenanceLoopAck", -1);
+
+            break;
+
+         /* maintenanceLoopReject */
+         case 18:
+            invokeStartElement (pctxt, "maintenanceLoopReject", -1);
+
+            pvalue->u.maintenanceLoopReject = ALLOC_ASN1ELEM (pctxt, H245MaintenanceLoopReject);
+
+            stat = asn1PD_H245MaintenanceLoopReject (pctxt, pvalue->u.maintenanceLoopReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "maintenanceLoopReject", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 20;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* communicationModeResponse */
+         case 20:
+            invokeStartElement (pctxt, "communicationModeResponse", -1);
+
+            pvalue->u.communicationModeResponse = ALLOC_ASN1ELEM (pctxt, H245CommunicationModeResponse);
+
+            stat = asn1PD_H245CommunicationModeResponse (pctxt, pvalue->u.communicationModeResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "communicationModeResponse", -1);
+
+            break;
+
+         /* conferenceResponse */
+         case 21:
+            invokeStartElement (pctxt, "conferenceResponse", -1);
+
+            pvalue->u.conferenceResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse);
+
+            stat = asn1PD_H245ConferenceResponse (pctxt, pvalue->u.conferenceResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "conferenceResponse", -1);
+
+            break;
+
+         /* multilinkResponse */
+         case 22:
+            invokeStartElement (pctxt, "multilinkResponse", -1);
+
+            pvalue->u.multilinkResponse = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse);
+
+            stat = asn1PD_H245MultilinkResponse (pctxt, pvalue->u.multilinkResponse);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multilinkResponse", -1);
+
+            break;
+
+         /* logicalChannelRateAcknowledge */
+         case 23:
+            invokeStartElement (pctxt, "logicalChannelRateAcknowledge", -1);
+
+            pvalue->u.logicalChannelRateAcknowledge = ALLOC_ASN1ELEM (pctxt, H245LogicalChannelRateAcknowledge);
+
+            stat = asn1PD_H245LogicalChannelRateAcknowledge (pctxt, pvalue->u.logicalChannelRateAcknowledge);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "logicalChannelRateAcknowledge", -1);
+
+            break;
+
+         /* logicalChannelRateReject */
+         case 24:
+            invokeStartElement (pctxt, "logicalChannelRateReject", -1);
+
+            pvalue->u.logicalChannelRateReject = ALLOC_ASN1ELEM (pctxt, H245LogicalChannelRateReject);
+
+            stat = asn1PD_H245LogicalChannelRateReject (pctxt, pvalue->u.logicalChannelRateReject);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "logicalChannelRateReject", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopOffCommand                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MaintenanceLoopOffCommand (OOCTXT* pctxt, H245MaintenanceLoopOffCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest_capabilityTabl  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   ALLOC_ASN1ARRAY (pctxt, pvalue, H245CapabilityTableEntryNumber);
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest_capabilityDesc  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245CapabilityDescriptorNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.capabilityTableEntryNumbersPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.capabilityDescriptorNumbersPresent = optbit;
+
+   /* decode multiplexCapability */
+
+   invokeStartElement (pctxt, "multiplexCapability", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->multiplexCapability);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->multiplexCapability);
+
+   invokeEndElement (pctxt, "multiplexCapability", -1);
+
+   /* decode capabilityTableEntryNumbers */
+
+   if (pvalue->m.capabilityTableEntryNumbersPresent) {
+      invokeStartElement (pctxt, "capabilityTableEntryNumbers", -1);
+
+      stat = asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (pctxt, &pvalue->capabilityTableEntryNumbers);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "capabilityTableEntryNumbers", -1);
+   }
+
+   /* decode capabilityDescriptorNumbers */
+
+   if (pvalue->m.capabilityDescriptorNumbersPresent) {
+      invokeStartElement (pctxt, "capabilityDescriptorNumbers", -1);
+
+      stat = asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (pctxt, &pvalue->capabilityDescriptorNumbers);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "capabilityDescriptorNumbers", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245SendTerminalCapabilitySet (OOCTXT* pctxt, H245SendTerminalCapabilitySet* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* specificRequest */
+         case 0:
+            invokeStartElement (pctxt, "specificRequest", -1);
+
+            pvalue->u.specificRequest = ALLOC_ASN1ELEM (pctxt, H245SendTerminalCapabilitySet_specificRequest);
+
+            stat = asn1PD_H245SendTerminalCapabilitySet_specificRequest (pctxt, pvalue->u.specificRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "specificRequest", -1);
+
+            break;
+
+         /* genericRequest */
+         case 1:
+            invokeStartElement (pctxt, "genericRequest", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "genericRequest", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCommand_encryptionAlgorithmID                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EncryptionCommand_encryptionAlgorithmID (OOCTXT* pctxt, H245EncryptionCommand_encryptionAlgorithmID* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode h233AlgorithmIdentifier */
+
+   invokeStartElement (pctxt, "h233AlgorithmIdentifier", -1);
+
+   stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->h233AlgorithmIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "h233AlgorithmIdentifier", -1);
+
+   /* decode associatedAlgorithm */
+
+   invokeStartElement (pctxt, "associatedAlgorithm", -1);
+
+   stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->associatedAlgorithm);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "associatedAlgorithm", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EncryptionCommand (OOCTXT* pctxt, H245EncryptionCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* encryptionSE */
+         case 0:
+            invokeStartElement (pctxt, "encryptionSE", -1);
+
+            pvalue->u.encryptionSE = ALLOC_ASN1ELEM (pctxt, ASN1DynOctStr);
+
+            stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue->u.encryptionSE);
+            if (stat != ASN_OK) return stat;
+            invokeOctStrValue (pctxt, pvalue->u.encryptionSE->numocts, pvalue->u.encryptionSE->data);
+
+            invokeEndElement (pctxt, "encryptionSE", -1);
+
+            break;
+
+         /* encryptionIVRequest */
+         case 1:
+            invokeStartElement (pctxt, "encryptionIVRequest", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "encryptionIVRequest", -1);
+
+            break;
+
+         /* encryptionAlgorithmID */
+         case 2:
+            invokeStartElement (pctxt, "encryptionAlgorithmID", -1);
+
+            pvalue->u.encryptionAlgorithmID = ALLOC_ASN1ELEM (pctxt, H245EncryptionCommand_encryptionAlgorithmID);
+
+            stat = asn1PD_H245EncryptionCommand_encryptionAlgorithmID (pctxt, pvalue->u.encryptionAlgorithmID);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "encryptionAlgorithmID", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand_scope                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FlowControlCommand_scope (OOCTXT* pctxt, H245FlowControlCommand_scope* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* logicalChannelNumber */
+      case 0:
+         invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+         stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelNumber);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+         break;
+
+      /* resourceID */
+      case 1:
+         invokeStartElement (pctxt, "resourceID", -1);
+
+         stat = decodeConsUInt16 (pctxt, &pvalue->u.resourceID, 0U, 65535U);
+         if (stat != ASN_OK) return stat;
+         invokeUIntValue (pctxt, pvalue->u.resourceID);
+
+         invokeEndElement (pctxt, "resourceID", -1);
+
+         break;
+
+      /* wholeMultiplex */
+      case 2:
+         invokeStartElement (pctxt, "wholeMultiplex", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "wholeMultiplex", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand_restriction                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FlowControlCommand_restriction (OOCTXT* pctxt, H245FlowControlCommand_restriction* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* maximumBitRate */
+      case 0:
+         invokeStartElement (pctxt, "maximumBitRate", -1);
+
+         stat = decodeConsUnsigned (pctxt, &pvalue->u.maximumBitRate, 0U, 16777215U);
+         if (stat != ASN_OK) return stat;
+         invokeUIntValue (pctxt, pvalue->u.maximumBitRate);
+
+         invokeEndElement (pctxt, "maximumBitRate", -1);
+
+         break;
+
+      /* noRestriction */
+      case 1:
+         invokeStartElement (pctxt, "noRestriction", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "noRestriction", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FlowControlCommand (OOCTXT* pctxt, H245FlowControlCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode scope */
+
+   invokeStartElement (pctxt, "scope", -1);
+
+   stat = asn1PD_H245FlowControlCommand_scope (pctxt, &pvalue->scope);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "scope", -1);
+
+   /* decode restriction */
+
+   invokeStartElement (pctxt, "restriction", -1);
+
+   stat = asn1PD_H245FlowControlCommand_restriction (pctxt, &pvalue->restriction);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "restriction", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand_gstnOptions                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EndSessionCommand_gstnOptions (OOCTXT* pctxt, H245EndSessionCommand_gstnOptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* telephonyMode */
+         case 0:
+            invokeStartElement (pctxt, "telephonyMode", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "telephonyMode", -1);
+
+            break;
+
+         /* v8bis */
+         case 1:
+            invokeStartElement (pctxt, "v8bis", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "v8bis", -1);
+
+            break;
+
+         /* v34DSVD */
+         case 2:
+            invokeStartElement (pctxt, "v34DSVD", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "v34DSVD", -1);
+
+            break;
+
+         /* v34DuplexFAX */
+         case 3:
+            invokeStartElement (pctxt, "v34DuplexFAX", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "v34DuplexFAX", -1);
+
+            break;
+
+         /* v34H324 */
+         case 4:
+            invokeStartElement (pctxt, "v34H324", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "v34H324", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 6;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand_isdnOptions                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EndSessionCommand_isdnOptions (OOCTXT* pctxt, H245EndSessionCommand_isdnOptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* telephonyMode */
+         case 0:
+            invokeStartElement (pctxt, "telephonyMode", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "telephonyMode", -1);
+
+            break;
+
+         /* v140 */
+         case 1:
+            invokeStartElement (pctxt, "v140", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "v140", -1);
+
+            break;
+
+         /* terminalOnHold */
+         case 2:
+            invokeStartElement (pctxt, "terminalOnHold", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "terminalOnHold", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EndSessionCommand (OOCTXT* pctxt, H245EndSessionCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* disconnect */
+         case 1:
+            invokeStartElement (pctxt, "disconnect", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "disconnect", -1);
+
+            break;
+
+         /* gstnOptions */
+         case 2:
+            invokeStartElement (pctxt, "gstnOptions", -1);
+
+            pvalue->u.gstnOptions = ALLOC_ASN1ELEM (pctxt, H245EndSessionCommand_gstnOptions);
+
+            stat = asn1PD_H245EndSessionCommand_gstnOptions (pctxt, pvalue->u.gstnOptions);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "gstnOptions", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* isdnOptions */
+         case 4:
+            invokeStartElement (pctxt, "isdnOptions", -1);
+
+            pvalue->u.isdnOptions = ALLOC_ASN1ELEM (pctxt, H245EndSessionCommand_isdnOptions);
+
+            stat = asn1PD_H245EndSessionCommand_isdnOptions (pctxt, pvalue->u.isdnOptions);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "isdnOptions", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoFastUpdateGOB              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_videoFastUpdateGOB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* decode firstGOB */
+
+   invokeStartElement (pctxt, "firstGOB", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->firstGOB, 0U, 17U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->firstGOB);
+
+   invokeEndElement (pctxt, "firstGOB", -1);
+
+   /* decode numberOfGOBs */
+
+   invokeStartElement (pctxt, "numberOfGOBs", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->numberOfGOBs, 1U, 18U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfGOBs);
+
+   invokeEndElement (pctxt, "numberOfGOBs", -1);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoFastUpdateMB               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_videoFastUpdateMB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.firstGOBPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.firstMBPresent = optbit;
+
+   /* decode firstGOB */
+
+   if (pvalue->m.firstGOBPresent) {
+      invokeStartElement (pctxt, "firstGOB", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->firstGOB, 0U, 255U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->firstGOB);
+
+      invokeEndElement (pctxt, "firstGOB", -1);
+   }
+
+   /* decode firstMB */
+
+   if (pvalue->m.firstMBPresent) {
+      invokeStartElement (pctxt, "firstMB", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->firstMB, 1U, 8192U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->firstMB);
+
+      invokeEndElement (pctxt, "firstMB", -1);
+   }
+
+   /* decode numberOfMBs */
+
+   invokeStartElement (pctxt, "numberOfMBs", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->numberOfMBs, 1U, 8192U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfMBs);
+
+   invokeEndElement (pctxt, "numberOfMBs", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  KeyProtectionMethod                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245KeyProtectionMethod (OOCTXT* pctxt, H245KeyProtectionMethod* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode secureChannel */
+
+   invokeStartElement (pctxt, "secureChannel", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->secureChannel);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->secureChannel);
+
+   invokeEndElement (pctxt, "secureChannel", -1);
+
+   /* decode sharedSecret */
+
+   invokeStartElement (pctxt, "sharedSecret", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->sharedSecret);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->sharedSecret);
+
+   invokeEndElement (pctxt, "sharedSecret", -1);
+
+   /* decode certProtectedKey */
+
+   invokeStartElement (pctxt, "certProtectedKey", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->certProtectedKey);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->certProtectedKey);
+
+   invokeEndElement (pctxt, "certProtectedKey", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionUpdateRequest                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245EncryptionUpdateRequest (OOCTXT* pctxt, H245EncryptionUpdateRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.keyProtectionMethodPresent = optbit;
+
+   /* decode keyProtectionMethod */
+
+   if (pvalue->m.keyProtectionMethodPresent) {
+      invokeStartElement (pctxt, "keyProtectionMethod", -1);
+
+      stat = asn1PD_H245KeyProtectionMethod (pctxt, &pvalue->keyProtectionMethod);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "keyProtectionMethod", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_progressiveRefinementStart_rep  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* doOneProgression */
+         case 0:
+            invokeStartElement (pctxt, "doOneProgression", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "doOneProgression", -1);
+
+            break;
+
+         /* doContinuousProgressions */
+         case 1:
+            invokeStartElement (pctxt, "doContinuousProgressions", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "doContinuousProgressions", -1);
+
+            break;
+
+         /* doOneIndependentProgression */
+         case 2:
+            invokeStartElement (pctxt, "doOneIndependentProgression", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "doOneIndependentProgression", -1);
+
+            break;
+
+         /* doContinuousIndependentProgressions */
+         case 3:
+            invokeStartElement (pctxt, "doContinuousIndependentProgressions", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "doContinuousIndependentProgressions", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_progressiveRefinementStart      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode repeatCount */
+
+   invokeStartElement (pctxt, "repeatCount", -1);
+
+   stat = asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (pctxt, &pvalue->repeatCount);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "repeatCount", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoBadMBs                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_videoBadMBs (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoBadMBs* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode firstMB */
+
+   invokeStartElement (pctxt, "firstMB", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->firstMB, 1U, 9216U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->firstMB);
+
+   invokeEndElement (pctxt, "firstMB", -1);
+
+   /* decode numberOfMBs */
+
+   invokeStartElement (pctxt, "numberOfMBs", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->numberOfMBs, 1U, 9216U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfMBs);
+
+   invokeEndElement (pctxt, "numberOfMBs", -1);
+
+   /* decode temporalReference */
+
+   invokeStartElement (pctxt, "temporalReference", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->temporalReference, 0U, 1023U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->temporalReference);
+
+   invokeEndElement (pctxt, "temporalReference", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PictureReference                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245PictureReference (OOCTXT* pctxt, H245PictureReference* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* pictureNumber */
+         case 0:
+            invokeStartElement (pctxt, "pictureNumber", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.pictureNumber, 0U, 1023U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.pictureNumber);
+
+            invokeEndElement (pctxt, "pictureNumber", -1);
+
+            break;
+
+         /* longTermPictureIndex */
+         case 1:
+            invokeStartElement (pctxt, "longTermPictureIndex", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.longTermPictureIndex, 0U, 255U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.longTermPictureIndex);
+
+            invokeEndElement (pctxt, "longTermPictureIndex", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245PictureReference                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245_SeqOfH245PictureReference (OOCTXT* pctxt, H245_SeqOfH245PictureReference* pvalue)
+{
+   int stat = ASN_OK;
+   H245PictureReference* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+   int lstat;
+
+   dListInit (pvalue);
+
+   for (;;) {
+      /* decode length determinant */
+
+      lstat = decodeLength (pctxt, &count);
+      if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
+         return lstat;
+      }
+
+      /* decode elements */
+
+      for (xx1 = 0; xx1 < count; xx1++) {
+         invokeStartElement (pctxt, "elem", xx1);
+
+         pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245PictureReference);
+
+         stat = asn1PD_H245PictureReference (pctxt, pdata);
+         if (stat != ASN_OK) return stat;
+         invokeEndElement (pctxt, "elem", xx1);
+
+         dListAppendNode (pctxt, pvalue, pdata);
+      }
+
+      if(lstat == ASN_OK) break;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_lostPartialPicture              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type_lostPartialPicture (OOCTXT* pctxt, H245MiscellaneousCommand_type_lostPartialPicture* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode pictureReference */
+
+   invokeStartElement (pctxt, "pictureReference", -1);
+
+   stat = asn1PD_H245PictureReference (pctxt, &pvalue->pictureReference);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "pictureReference", -1);
+
+   /* decode firstMB */
+
+   invokeStartElement (pctxt, "firstMB", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->firstMB, 1U, 9216U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->firstMB);
+
+   invokeEndElement (pctxt, "firstMB", -1);
+
+   /* decode numberOfMBs */
+
+   invokeStartElement (pctxt, "numberOfMBs", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->numberOfMBs, 1U, 9216U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfMBs);
+
+   invokeEndElement (pctxt, "numberOfMBs", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousCommand_type (OOCTXT* pctxt, H245MiscellaneousCommand_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 9);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* equaliseDelay */
+         case 0:
+            invokeStartElement (pctxt, "equaliseDelay", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "equaliseDelay", -1);
+
+            break;
+
+         /* zeroDelay */
+         case 1:
+            invokeStartElement (pctxt, "zeroDelay", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "zeroDelay", -1);
+
+            break;
+
+         /* multipointModeCommand */
+         case 2:
+            invokeStartElement (pctxt, "multipointModeCommand", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "multipointModeCommand", -1);
+
+            break;
+
+         /* cancelMultipointModeCommand */
+         case 3:
+            invokeStartElement (pctxt, "cancelMultipointModeCommand", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelMultipointModeCommand", -1);
+
+            break;
+
+         /* videoFreezePicture */
+         case 4:
+            invokeStartElement (pctxt, "videoFreezePicture", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "videoFreezePicture", -1);
+
+            break;
+
+         /* videoFastUpdatePicture */
+         case 5:
+            invokeStartElement (pctxt, "videoFastUpdatePicture", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "videoFastUpdatePicture", -1);
+
+            break;
+
+         /* videoFastUpdateGOB */
+         case 6:
+            invokeStartElement (pctxt, "videoFastUpdateGOB", -1);
+
+            pvalue->u.videoFastUpdateGOB = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB);
+
+            stat = asn1PD_H245MiscellaneousCommand_type_videoFastUpdateGOB (pctxt, pvalue->u.videoFastUpdateGOB);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoFastUpdateGOB", -1);
+
+            break;
+
+         /* videoTemporalSpatialTradeOff */
+         case 7:
+            invokeStartElement (pctxt, "videoTemporalSpatialTradeOff", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.videoTemporalSpatialTradeOff, 0U, 31U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.videoTemporalSpatialTradeOff);
+
+            invokeEndElement (pctxt, "videoTemporalSpatialTradeOff", -1);
+
+            break;
+
+         /* videoSendSyncEveryGOB */
+         case 8:
+            invokeStartElement (pctxt, "videoSendSyncEveryGOB", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "videoSendSyncEveryGOB", -1);
+
+            break;
+
+         /* videoSendSyncEveryGOBCancel */
+         case 9:
+            invokeStartElement (pctxt, "videoSendSyncEveryGOBCancel", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "videoSendSyncEveryGOBCancel", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 11;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* videoFastUpdateMB */
+         case 11:
+            invokeStartElement (pctxt, "videoFastUpdateMB", -1);
+
+            pvalue->u.videoFastUpdateMB = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB);
+
+            stat = asn1PD_H245MiscellaneousCommand_type_videoFastUpdateMB (pctxt, pvalue->u.videoFastUpdateMB);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoFastUpdateMB", -1);
+
+            break;
+
+         /* maxH223MUXPDUsize */
+         case 12:
+            invokeStartElement (pctxt, "maxH223MUXPDUsize", -1);
+
+            stat = decodeConsUInt16 (pctxt, &pvalue->u.maxH223MUXPDUsize, 1U, 65535U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.maxH223MUXPDUsize);
+
+            invokeEndElement (pctxt, "maxH223MUXPDUsize", -1);
+
+            break;
+
+         /* encryptionUpdate */
+         case 13:
+            invokeStartElement (pctxt, "encryptionUpdate", -1);
+
+            pvalue->u.encryptionUpdate = ALLOC_ASN1ELEM (pctxt, H245EncryptionSync);
+
+            stat = asn1PD_H245EncryptionSync (pctxt, pvalue->u.encryptionUpdate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "encryptionUpdate", -1);
+
+            break;
+
+         /* encryptionUpdateRequest */
+         case 14:
+            invokeStartElement (pctxt, "encryptionUpdateRequest", -1);
+
+            pvalue->u.encryptionUpdateRequest = ALLOC_ASN1ELEM (pctxt, H245EncryptionUpdateRequest);
+
+            stat = asn1PD_H245EncryptionUpdateRequest (pctxt, pvalue->u.encryptionUpdateRequest);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "encryptionUpdateRequest", -1);
+
+            break;
+
+         /* switchReceiveMediaOff */
+         case 15:
+            invokeStartElement (pctxt, "switchReceiveMediaOff", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "switchReceiveMediaOff", -1);
+
+            break;
+
+         /* switchReceiveMediaOn */
+         case 16:
+            invokeStartElement (pctxt, "switchReceiveMediaOn", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "switchReceiveMediaOn", -1);
+
+            break;
+
+         /* progressiveRefinementStart */
+         case 17:
+            invokeStartElement (pctxt, "progressiveRefinementStart", -1);
+
+            pvalue->u.progressiveRefinementStart = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart);
+
+            stat = asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart (pctxt, pvalue->u.progressiveRefinementStart);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "progressiveRefinementStart", -1);
+
+            break;
+
+         /* progressiveRefinementAbortOne */
+         case 18:
+            invokeStartElement (pctxt, "progressiveRefinementAbortOne", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "progressiveRefinementAbortOne", -1);
+
+            break;
+
+         /* progressiveRefinementAbortContinuous */
+         case 19:
+            invokeStartElement (pctxt, "progressiveRefinementAbortContinuous", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "progressiveRefinementAbortContinuous", -1);
+
+            break;
+
+         /* videoBadMBs */
+         case 20:
+            invokeStartElement (pctxt, "videoBadMBs", -1);
+
+            pvalue->u.videoBadMBs = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_videoBadMBs);
+
+            stat = asn1PD_H245MiscellaneousCommand_type_videoBadMBs (pctxt, pvalue->u.videoBadMBs);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoBadMBs", -1);
+
+            break;
+
+         /* lostPicture */
+         case 21:
+            invokeStartElement (pctxt, "lostPicture", -1);
+
+            pvalue->u.lostPicture = ALLOC_ASN1ELEM (pctxt, H245_SeqOfH245PictureReference);
+
+            stat = asn1PD_H245_SeqOfH245PictureReference (pctxt, pvalue->u.lostPicture);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "lostPicture", -1);
+
+            break;
+
+         /* lostPartialPicture */
+         case 22:
+            invokeStartElement (pctxt, "lostPartialPicture", -1);
+
+            pvalue->u.lostPartialPicture = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_lostPartialPicture);
+
+            stat = asn1PD_H245MiscellaneousCommand_type_lostPartialPicture (pctxt, pvalue->u.lostPartialPicture);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "lostPartialPicture", -1);
+
+            break;
+
+         /* recoveryReferencePicture */
+         case 23:
+            invokeStartElement (pctxt, "recoveryReferencePicture", -1);
+
+            pvalue->u.recoveryReferencePicture = ALLOC_ASN1ELEM (pctxt, H245_SeqOfH245PictureReference);
+
+            stat = asn1PD_H245_SeqOfH245PictureReference (pctxt, pvalue->u.recoveryReferencePicture);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "recoveryReferencePicture", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousCommand (OOCTXT* pctxt, H245MiscellaneousCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode logicalChannelNumber */
+
+   invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245MiscellaneousCommand_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeCommand_communicationModeTable           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CommunicationModeCommand_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeCommand_communicationModeTable* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   H245CommunicationModeTableEntry* pdata;
+   ASN1UINT count = 0;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &count);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   dListInit (pvalue);
+
+   for (xx1 = 0; xx1 < count; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245CommunicationModeTableEntry);
+
+      stat = asn1PD_H245CommunicationModeTableEntry (pctxt, pdata);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+      dListAppendNode (pctxt, pvalue, pdata);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeCommand                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CommunicationModeCommand (OOCTXT* pctxt, H245CommunicationModeCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode communicationModeTable */
+
+   invokeStartElement (pctxt, "communicationModeTable", -1);
+
+   stat = asn1PD_H245CommunicationModeCommand_communicationModeTable (pctxt, &pvalue->communicationModeTable);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "communicationModeTable", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SubstituteConferenceIDCommand_conferenceIdentifier        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245SubstituteConferenceIDCommand_conferenceIdentifier (OOCTXT* pctxt, H245SubstituteConferenceIDCommand_conferenceIdentifier* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SubstituteConferenceIDCommand                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245SubstituteConferenceIDCommand (OOCTXT* pctxt, H245SubstituteConferenceIDCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode conferenceIdentifier */
+
+   invokeStartElement (pctxt, "conferenceIdentifier", -1);
+
+   stat = asn1PD_H245SubstituteConferenceIDCommand_conferenceIdentifier (pctxt, &pvalue->conferenceIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "conferenceIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceCommand (OOCTXT* pctxt, H245ConferenceCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* broadcastMyLogicalChannel */
+         case 0:
+            invokeStartElement (pctxt, "broadcastMyLogicalChannel", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.broadcastMyLogicalChannel);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "broadcastMyLogicalChannel", -1);
+
+            break;
+
+         /* cancelBroadcastMyLogicalChannel */
+         case 1:
+            invokeStartElement (pctxt, "cancelBroadcastMyLogicalChannel", -1);
+
+            stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.cancelBroadcastMyLogicalChannel);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "cancelBroadcastMyLogicalChannel", -1);
+
+            break;
+
+         /* makeTerminalBroadcaster */
+         case 2:
+            invokeStartElement (pctxt, "makeTerminalBroadcaster", -1);
+
+            pvalue->u.makeTerminalBroadcaster = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.makeTerminalBroadcaster);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "makeTerminalBroadcaster", -1);
+
+            break;
+
+         /* cancelMakeTerminalBroadcaster */
+         case 3:
+            invokeStartElement (pctxt, "cancelMakeTerminalBroadcaster", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelMakeTerminalBroadcaster", -1);
+
+            break;
+
+         /* sendThisSource */
+         case 4:
+            invokeStartElement (pctxt, "sendThisSource", -1);
+
+            pvalue->u.sendThisSource = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.sendThisSource);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "sendThisSource", -1);
+
+            break;
+
+         /* cancelSendThisSource */
+         case 5:
+            invokeStartElement (pctxt, "cancelSendThisSource", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelSendThisSource", -1);
+
+            break;
+
+         /* dropConference */
+         case 6:
+            invokeStartElement (pctxt, "dropConference", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "dropConference", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 8;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* substituteConferenceIDCommand */
+         case 8:
+            invokeStartElement (pctxt, "substituteConferenceIDCommand", -1);
+
+            pvalue->u.substituteConferenceIDCommand = ALLOC_ASN1ELEM (pctxt, H245SubstituteConferenceIDCommand);
+
+            stat = asn1PD_H245SubstituteConferenceIDCommand (pctxt, pvalue->u.substituteConferenceIDCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "substituteConferenceIDCommand", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration_h223ModeChange               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223MultiplexReconfiguration_h223ModeChange (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223ModeChange* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* toLevel0 */
+         case 0:
+            invokeStartElement (pctxt, "toLevel0", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "toLevel0", -1);
+
+            break;
+
+         /* toLevel1 */
+         case 1:
+            invokeStartElement (pctxt, "toLevel1", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "toLevel1", -1);
+
+            break;
+
+         /* toLevel2 */
+         case 2:
+            invokeStartElement (pctxt, "toLevel2", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "toLevel2", -1);
+
+            break;
+
+         /* toLevel2withOptionalHeader */
+         case 3:
+            invokeStartElement (pctxt, "toLevel2withOptionalHeader", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "toLevel2withOptionalHeader", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration_h223AnnexADoubleFlag         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* start */
+         case 0:
+            invokeStartElement (pctxt, "start", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "start", -1);
+
+            break;
+
+         /* stop */
+         case 1:
+            invokeStartElement (pctxt, "stop", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "stop", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223MultiplexReconfiguration (OOCTXT* pctxt, H245H223MultiplexReconfiguration* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* h223ModeChange */
+         case 0:
+            invokeStartElement (pctxt, "h223ModeChange", -1);
+
+            pvalue->u.h223ModeChange = ALLOC_ASN1ELEM (pctxt, H245H223MultiplexReconfiguration_h223ModeChange);
+
+            stat = asn1PD_H245H223MultiplexReconfiguration_h223ModeChange (pctxt, pvalue->u.h223ModeChange);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h223ModeChange", -1);
+
+            break;
+
+         /* h223AnnexADoubleFlag */
+         case 1:
+            invokeStartElement (pctxt, "h223AnnexADoubleFlag", -1);
+
+            pvalue->u.h223AnnexADoubleFlag = ALLOC_ASN1ELEM (pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag);
+
+            stat = asn1PD_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (pctxt, pvalue->u.h223AnnexADoubleFlag);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h223AnnexADoubleFlag", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1_clockRecovery                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_clockRecovery* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nullClockRecovery */
+         case 0:
+            invokeStartElement (pctxt, "nullClockRecovery", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nullClockRecovery", -1);
+
+            break;
+
+         /* srtsClockRecovery */
+         case 1:
+            invokeStartElement (pctxt, "srtsClockRecovery", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "srtsClockRecovery", -1);
+
+            break;
+
+         /* adaptiveClockRecovery */
+         case 2:
+            invokeStartElement (pctxt, "adaptiveClockRecovery", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "adaptiveClockRecovery", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1_errorCorrection                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_errorCorrection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nullErrorCorrection */
+         case 0:
+            invokeStartElement (pctxt, "nullErrorCorrection", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nullErrorCorrection", -1);
+
+            break;
+
+         /* longInterleaver */
+         case 1:
+            invokeStartElement (pctxt, "longInterleaver", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "longInterleaver", -1);
+
+            break;
+
+         /* shortInterleaver */
+         case 2:
+            invokeStartElement (pctxt, "shortInterleaver", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "shortInterleaver", -1);
+
+            break;
+
+         /* errorCorrectionOnly */
+         case 3:
+            invokeStartElement (pctxt, "errorCorrectionOnly", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "errorCorrectionOnly", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode clockRecovery */
+
+   invokeStartElement (pctxt, "clockRecovery", -1);
+
+   stat = asn1PD_H245NewATMVCCommand_aal_aal1_clockRecovery (pctxt, &pvalue->clockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "clockRecovery", -1);
+
+   /* decode errorCorrection */
+
+   invokeStartElement (pctxt, "errorCorrection", -1);
+
+   stat = asn1PD_H245NewATMVCCommand_aal_aal1_errorCorrection (pctxt, &pvalue->errorCorrection);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "errorCorrection", -1);
+
+   /* decode structuredDataTransfer */
+
+   invokeStartElement (pctxt, "structuredDataTransfer", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->structuredDataTransfer);
+
+   invokeEndElement (pctxt, "structuredDataTransfer", -1);
+
+   /* decode partiallyFilledCells */
+
+   invokeStartElement (pctxt, "partiallyFilledCells", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->partiallyFilledCells);
+
+   invokeEndElement (pctxt, "partiallyFilledCells", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal5                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal_aal5 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal5* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardMaximumSDUSize */
+
+   invokeStartElement (pctxt, "forwardMaximumSDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->forwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->forwardMaximumSDUSize);
+
+   invokeEndElement (pctxt, "forwardMaximumSDUSize", -1);
+
+   /* decode backwardMaximumSDUSize */
+
+   invokeStartElement (pctxt, "backwardMaximumSDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->backwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->backwardMaximumSDUSize);
+
+   invokeEndElement (pctxt, "backwardMaximumSDUSize", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand_aal (OOCTXT* pctxt, H245NewATMVCCommand_aal* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* aal1 */
+         case 0:
+            invokeStartElement (pctxt, "aal1", -1);
+
+            pvalue->u.aal1 = ALLOC_ASN1ELEM (pctxt, H245NewATMVCCommand_aal_aal1);
+
+            stat = asn1PD_H245NewATMVCCommand_aal_aal1 (pctxt, pvalue->u.aal1);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "aal1", -1);
+
+            break;
+
+         /* aal5 */
+         case 1:
+            invokeStartElement (pctxt, "aal5", -1);
+
+            pvalue->u.aal5 = ALLOC_ASN1ELEM (pctxt, H245NewATMVCCommand_aal_aal5);
+
+            stat = asn1PD_H245NewATMVCCommand_aal_aal5 (pctxt, pvalue->u.aal5);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "aal5", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_multiplex                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_multiplex* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* noMultiplex */
+         case 0:
+            invokeStartElement (pctxt, "noMultiplex", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noMultiplex", -1);
+
+            break;
+
+         /* transportStream */
+         case 1:
+            invokeStartElement (pctxt, "transportStream", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transportStream", -1);
+
+            break;
+
+         /* programStream */
+         case 2:
+            invokeStartElement (pctxt, "programStream", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "programStream", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_reverseParameters_multiplex               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters_multiplex* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* noMultiplex */
+         case 0:
+            invokeStartElement (pctxt, "noMultiplex", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noMultiplex", -1);
+
+            break;
+
+         /* transportStream */
+         case 1:
+            invokeStartElement (pctxt, "transportStream", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transportStream", -1);
+
+            break;
+
+         /* programStream */
+         case 2:
+            invokeStartElement (pctxt, "programStream", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "programStream", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_reverseParameters                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand_reverseParameters (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   /* decode bitRateLockedToPCRClock */
+
+   invokeStartElement (pctxt, "bitRateLockedToPCRClock", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToPCRClock);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->bitRateLockedToPCRClock);
+
+   invokeEndElement (pctxt, "bitRateLockedToPCRClock", -1);
+
+   /* decode bitRateLockedToNetworkClock */
+
+   invokeStartElement (pctxt, "bitRateLockedToNetworkClock", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToNetworkClock);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->bitRateLockedToNetworkClock);
+
+   invokeEndElement (pctxt, "bitRateLockedToNetworkClock", -1);
+
+   /* decode multiplex */
+
+   invokeStartElement (pctxt, "multiplex", -1);
+
+   stat = asn1PD_H245NewATMVCCommand_reverseParameters_multiplex (pctxt, &pvalue->multiplex);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplex", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCCommand (OOCTXT* pctxt, H245NewATMVCCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode resourceID */
+
+   invokeStartElement (pctxt, "resourceID", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->resourceID, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->resourceID);
+
+   invokeEndElement (pctxt, "resourceID", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   /* decode bitRateLockedToPCRClock */
+
+   invokeStartElement (pctxt, "bitRateLockedToPCRClock", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToPCRClock);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->bitRateLockedToPCRClock);
+
+   invokeEndElement (pctxt, "bitRateLockedToPCRClock", -1);
+
+   /* decode bitRateLockedToNetworkClock */
+
+   invokeStartElement (pctxt, "bitRateLockedToNetworkClock", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToNetworkClock);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->bitRateLockedToNetworkClock);
+
+   invokeEndElement (pctxt, "bitRateLockedToNetworkClock", -1);
+
+   /* decode aal */
+
+   invokeStartElement (pctxt, "aal", -1);
+
+   stat = asn1PD_H245NewATMVCCommand_aal (pctxt, &pvalue->aal);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "aal", -1);
+
+   /* decode multiplex */
+
+   invokeStartElement (pctxt, "multiplex", -1);
+
+   stat = asn1PD_H245NewATMVCCommand_multiplex (pctxt, &pvalue->multiplex);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplex", -1);
+
+   /* decode reverseParameters */
+
+   invokeStartElement (pctxt, "reverseParameters", -1);
+
+   stat = asn1PD_H245NewATMVCCommand_reverseParameters (pctxt, &pvalue->reverseParameters);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "reverseParameters", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationCommand_status              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MobileMultilinkReconfigurationCommand_status (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand_status* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* synchronized_ */
+         case 0:
+            invokeStartElement (pctxt, "synchronized_", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "synchronized_", -1);
+
+            break;
+
+         /* reconfiguration */
+         case 1:
+            invokeStartElement (pctxt, "reconfiguration", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "reconfiguration", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationCommand                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MobileMultilinkReconfigurationCommand (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sampleSize */
+
+   invokeStartElement (pctxt, "sampleSize", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sampleSize, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sampleSize);
+
+   invokeEndElement (pctxt, "sampleSize", -1);
+
+   /* decode samplesPerFrame */
+
+   invokeStartElement (pctxt, "samplesPerFrame", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->samplesPerFrame, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->samplesPerFrame);
+
+   invokeEndElement (pctxt, "samplesPerFrame", -1);
+
+   /* decode status */
+
+   invokeStartElement (pctxt, "status", -1);
+
+   stat = asn1PD_H245MobileMultilinkReconfigurationCommand_status (pctxt, &pvalue->status);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "status", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommandMessage                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245CommandMessage (OOCTXT* pctxt, H245CommandMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* maintenanceLoopOffCommand */
+         case 1:
+            invokeStartElement (pctxt, "maintenanceLoopOffCommand", -1);
+
+            pvalue->u.maintenanceLoopOffCommand = ALLOC_ASN1ELEM (pctxt, H245MaintenanceLoopOffCommand);
+
+            stat = asn1PD_H245MaintenanceLoopOffCommand (pctxt, pvalue->u.maintenanceLoopOffCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "maintenanceLoopOffCommand", -1);
+
+            break;
+
+         /* sendTerminalCapabilitySet */
+         case 2:
+            invokeStartElement (pctxt, "sendTerminalCapabilitySet", -1);
+
+            pvalue->u.sendTerminalCapabilitySet = ALLOC_ASN1ELEM (pctxt, H245SendTerminalCapabilitySet);
+
+            stat = asn1PD_H245SendTerminalCapabilitySet (pctxt, pvalue->u.sendTerminalCapabilitySet);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "sendTerminalCapabilitySet", -1);
+
+            break;
+
+         /* encryptionCommand */
+         case 3:
+            invokeStartElement (pctxt, "encryptionCommand", -1);
+
+            pvalue->u.encryptionCommand = ALLOC_ASN1ELEM (pctxt, H245EncryptionCommand);
+
+            stat = asn1PD_H245EncryptionCommand (pctxt, pvalue->u.encryptionCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "encryptionCommand", -1);
+
+            break;
+
+         /* flowControlCommand */
+         case 4:
+            invokeStartElement (pctxt, "flowControlCommand", -1);
+
+            pvalue->u.flowControlCommand = ALLOC_ASN1ELEM (pctxt, H245FlowControlCommand);
+
+            stat = asn1PD_H245FlowControlCommand (pctxt, pvalue->u.flowControlCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "flowControlCommand", -1);
+
+            break;
+
+         /* endSessionCommand */
+         case 5:
+            invokeStartElement (pctxt, "endSessionCommand", -1);
+
+            pvalue->u.endSessionCommand = ALLOC_ASN1ELEM (pctxt, H245EndSessionCommand);
+
+            stat = asn1PD_H245EndSessionCommand (pctxt, pvalue->u.endSessionCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "endSessionCommand", -1);
+
+            break;
+
+         /* miscellaneousCommand */
+         case 6:
+            invokeStartElement (pctxt, "miscellaneousCommand", -1);
+
+            pvalue->u.miscellaneousCommand = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand);
+
+            stat = asn1PD_H245MiscellaneousCommand (pctxt, pvalue->u.miscellaneousCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "miscellaneousCommand", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 8;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* communicationModeCommand */
+         case 8:
+            invokeStartElement (pctxt, "communicationModeCommand", -1);
+
+            pvalue->u.communicationModeCommand = ALLOC_ASN1ELEM (pctxt, H245CommunicationModeCommand);
+
+            stat = asn1PD_H245CommunicationModeCommand (pctxt, pvalue->u.communicationModeCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "communicationModeCommand", -1);
+
+            break;
+
+         /* conferenceCommand */
+         case 9:
+            invokeStartElement (pctxt, "conferenceCommand", -1);
+
+            pvalue->u.conferenceCommand = ALLOC_ASN1ELEM (pctxt, H245ConferenceCommand);
+
+            stat = asn1PD_H245ConferenceCommand (pctxt, pvalue->u.conferenceCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "conferenceCommand", -1);
+
+            break;
+
+         /* h223MultiplexReconfiguration */
+         case 10:
+            invokeStartElement (pctxt, "h223MultiplexReconfiguration", -1);
+
+            pvalue->u.h223MultiplexReconfiguration = ALLOC_ASN1ELEM (pctxt, H245H223MultiplexReconfiguration);
+
+            stat = asn1PD_H245H223MultiplexReconfiguration (pctxt, pvalue->u.h223MultiplexReconfiguration);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h223MultiplexReconfiguration", -1);
+
+            break;
+
+         /* newATMVCCommand */
+         case 11:
+            invokeStartElement (pctxt, "newATMVCCommand", -1);
+
+            pvalue->u.newATMVCCommand = ALLOC_ASN1ELEM (pctxt, H245NewATMVCCommand);
+
+            stat = asn1PD_H245NewATMVCCommand (pctxt, pvalue->u.newATMVCCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "newATMVCCommand", -1);
+
+            break;
+
+         /* mobileMultilinkReconfigurationCommand */
+         case 12:
+            invokeStartElement (pctxt, "mobileMultilinkReconfigurationCommand", -1);
+
+            pvalue->u.mobileMultilinkReconfigurationCommand = ALLOC_ASN1ELEM (pctxt, H245MobileMultilinkReconfigurationCommand);
+
+            stat = asn1PD_H245MobileMultilinkReconfigurationCommand (pctxt, pvalue->u.mobileMultilinkReconfigurationCommand);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "mobileMultilinkReconfigurationCommand", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotUnderstood                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FunctionNotUnderstood (OOCTXT* pctxt, H245FunctionNotUnderstood* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* request */
+      case 0:
+         invokeStartElement (pctxt, "request", -1);
+
+         pvalue->u.request = ALLOC_ASN1ELEM (pctxt, H245RequestMessage);
+
+         stat = asn1PD_H245RequestMessage (pctxt, pvalue->u.request);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "request", -1);
+
+         break;
+
+      /* response */
+      case 1:
+         invokeStartElement (pctxt, "response", -1);
+
+         pvalue->u.response = ALLOC_ASN1ELEM (pctxt, H245ResponseMessage);
+
+         stat = asn1PD_H245ResponseMessage (pctxt, pvalue->u.response);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "response", -1);
+
+         break;
+
+      /* command */
+      case 2:
+         invokeStartElement (pctxt, "command", -1);
+
+         pvalue->u.command = ALLOC_ASN1ELEM (pctxt, H245CommandMessage);
+
+         stat = asn1PD_H245CommandMessage (pctxt, pvalue->u.command);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "command", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationRelease                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MasterSlaveDeterminationRelease (OOCTXT* pctxt, H245MasterSlaveDeterminationRelease* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetRelease                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalCapabilitySetRelease (OOCTXT* pctxt, H245TerminalCapabilitySetRelease* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelConfirm                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245OpenLogicalChannelConfirm (OOCTXT* pctxt, H245OpenLogicalChannelConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseRelease                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestChannelCloseRelease (OOCTXT* pctxt, H245RequestChannelCloseRelease* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardLogicalChannelNumber */
+
+   invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendRelease_multiplexTableEntryNumber       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendRelease_multiplexTableEntryNumber* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendRelease                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultiplexEntrySendRelease (OOCTXT* pctxt, H245MultiplexEntrySendRelease* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode multiplexTableEntryNumber */
+
+   invokeStartElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   stat = asn1PD_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplexTableEntryNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRelease_entryNumbers                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryRelease_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryRelease_entryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* decode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeLength (pctxt, &pvalue->n);
+   if (stat != ASN_OK) return stat;
+
+   /* decode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      invokeStartElement (pctxt, "elem", xx1);
+
+      stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+      invokeEndElement (pctxt, "elem", xx1);
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRelease                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestMultiplexEntryRelease (OOCTXT* pctxt, H245RequestMultiplexEntryRelease* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode entryNumbers */
+
+   invokeStartElement (pctxt, "entryNumbers", -1);
+
+   stat = asn1PD_H245RequestMultiplexEntryRelease_entryNumbers (pctxt, &pvalue->entryNumbers);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "entryNumbers", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeRelease                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245RequestModeRelease (OOCTXT* pctxt, H245RequestModeRelease* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication_type_videoNotDecodedMBs           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousIndication_type_videoNotDecodedMBs (OOCTXT* pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode firstMB */
+
+   invokeStartElement (pctxt, "firstMB", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->firstMB, 1U, 8192U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->firstMB);
+
+   invokeEndElement (pctxt, "firstMB", -1);
+
+   /* decode numberOfMBs */
+
+   invokeStartElement (pctxt, "numberOfMBs", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->numberOfMBs, 1U, 8192U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->numberOfMBs);
+
+   invokeEndElement (pctxt, "numberOfMBs", -1);
+
+   /* decode temporalReference */
+
+   invokeStartElement (pctxt, "temporalReference", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->temporalReference, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->temporalReference);
+
+   invokeEndElement (pctxt, "temporalReference", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication_type                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousIndication_type (OOCTXT* pctxt, H245MiscellaneousIndication_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 9);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* logicalChannelActive */
+         case 0:
+            invokeStartElement (pctxt, "logicalChannelActive", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "logicalChannelActive", -1);
+
+            break;
+
+         /* logicalChannelInactive */
+         case 1:
+            invokeStartElement (pctxt, "logicalChannelInactive", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "logicalChannelInactive", -1);
+
+            break;
+
+         /* multipointConference */
+         case 2:
+            invokeStartElement (pctxt, "multipointConference", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "multipointConference", -1);
+
+            break;
+
+         /* cancelMultipointConference */
+         case 3:
+            invokeStartElement (pctxt, "cancelMultipointConference", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelMultipointConference", -1);
+
+            break;
+
+         /* multipointZeroComm */
+         case 4:
+            invokeStartElement (pctxt, "multipointZeroComm", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "multipointZeroComm", -1);
+
+            break;
+
+         /* cancelMultipointZeroComm */
+         case 5:
+            invokeStartElement (pctxt, "cancelMultipointZeroComm", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelMultipointZeroComm", -1);
+
+            break;
+
+         /* multipointSecondaryStatus */
+         case 6:
+            invokeStartElement (pctxt, "multipointSecondaryStatus", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "multipointSecondaryStatus", -1);
+
+            break;
+
+         /* cancelMultipointSecondaryStatus */
+         case 7:
+            invokeStartElement (pctxt, "cancelMultipointSecondaryStatus", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelMultipointSecondaryStatus", -1);
+
+            break;
+
+         /* videoIndicateReadyToActivate */
+         case 8:
+            invokeStartElement (pctxt, "videoIndicateReadyToActivate", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "videoIndicateReadyToActivate", -1);
+
+            break;
+
+         /* videoTemporalSpatialTradeOff */
+         case 9:
+            invokeStartElement (pctxt, "videoTemporalSpatialTradeOff", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.videoTemporalSpatialTradeOff, 0U, 31U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.videoTemporalSpatialTradeOff);
+
+            invokeEndElement (pctxt, "videoTemporalSpatialTradeOff", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 11;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* videoNotDecodedMBs */
+         case 11:
+            invokeStartElement (pctxt, "videoNotDecodedMBs", -1);
+
+            pvalue->u.videoNotDecodedMBs = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs);
+
+            stat = asn1PD_H245MiscellaneousIndication_type_videoNotDecodedMBs (pctxt, pvalue->u.videoNotDecodedMBs);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoNotDecodedMBs", -1);
+
+            break;
+
+         /* transportCapability */
+         case 12:
+            invokeStartElement (pctxt, "transportCapability", -1);
+
+            pvalue->u.transportCapability = ALLOC_ASN1ELEM (pctxt, H245TransportCapability);
+
+            stat = asn1PD_H245TransportCapability (pctxt, pvalue->u.transportCapability);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "transportCapability", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MiscellaneousIndication (OOCTXT* pctxt, H245MiscellaneousIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode logicalChannelNumber */
+
+   invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+   /* decode type */
+
+   invokeStartElement (pctxt, "type", -1);
+
+   stat = asn1PD_H245MiscellaneousIndication_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "type", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  JitterIndication_scope                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245JitterIndication_scope (OOCTXT* pctxt, H245JitterIndication_scope* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* logicalChannelNumber */
+      case 0:
+         invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+         stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelNumber);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+         break;
+
+      /* resourceID */
+      case 1:
+         invokeStartElement (pctxt, "resourceID", -1);
+
+         stat = decodeConsUInt16 (pctxt, &pvalue->u.resourceID, 0U, 65535U);
+         if (stat != ASN_OK) return stat;
+         invokeUIntValue (pctxt, pvalue->u.resourceID);
+
+         invokeEndElement (pctxt, "resourceID", -1);
+
+         break;
+
+      /* wholeMultiplex */
+      case 2:
+         invokeStartElement (pctxt, "wholeMultiplex", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "wholeMultiplex", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  JitterIndication                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245JitterIndication (OOCTXT* pctxt, H245JitterIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.skippedFrameCountPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.additionalDecoderBufferPresent = optbit;
+
+   /* decode scope */
+
+   invokeStartElement (pctxt, "scope", -1);
+
+   stat = asn1PD_H245JitterIndication_scope (pctxt, &pvalue->scope);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "scope", -1);
+
+   /* decode estimatedReceivedJitterMantissa */
+
+   invokeStartElement (pctxt, "estimatedReceivedJitterMantissa", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->estimatedReceivedJitterMantissa, 0U, 3U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->estimatedReceivedJitterMantissa);
+
+   invokeEndElement (pctxt, "estimatedReceivedJitterMantissa", -1);
+
+   /* decode estimatedReceivedJitterExponent */
+
+   invokeStartElement (pctxt, "estimatedReceivedJitterExponent", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->estimatedReceivedJitterExponent, 0U, 7U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->estimatedReceivedJitterExponent);
+
+   invokeEndElement (pctxt, "estimatedReceivedJitterExponent", -1);
+
+   /* decode skippedFrameCount */
+
+   if (pvalue->m.skippedFrameCountPresent) {
+      invokeStartElement (pctxt, "skippedFrameCount", -1);
+
+      stat = decodeConsUInt8 (pctxt, &pvalue->skippedFrameCount, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->skippedFrameCount);
+
+      invokeEndElement (pctxt, "skippedFrameCount", -1);
+   }
+
+   /* decode additionalDecoderBuffer */
+
+   if (pvalue->m.additionalDecoderBufferPresent) {
+      invokeStartElement (pctxt, "additionalDecoderBuffer", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->additionalDecoderBuffer, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->additionalDecoderBuffer);
+
+      invokeEndElement (pctxt, "additionalDecoderBuffer", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223SkewIndication                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H223SkewIndication (OOCTXT* pctxt, H245H223SkewIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode logicalChannelNumber1 */
+
+   invokeStartElement (pctxt, "logicalChannelNumber1", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber1);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber1", -1);
+
+   /* decode logicalChannelNumber2 */
+
+   invokeStartElement (pctxt, "logicalChannelNumber2", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber2);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber2", -1);
+
+   /* decode skew */
+
+   invokeStartElement (pctxt, "skew", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->skew, 0U, 4095U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->skew);
+
+   invokeEndElement (pctxt, "skew", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1_clockRecovery                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_clockRecovery* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nullClockRecovery */
+         case 0:
+            invokeStartElement (pctxt, "nullClockRecovery", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nullClockRecovery", -1);
+
+            break;
+
+         /* srtsClockRecovery */
+         case 1:
+            invokeStartElement (pctxt, "srtsClockRecovery", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "srtsClockRecovery", -1);
+
+            break;
+
+         /* adaptiveClockRecovery */
+         case 2:
+            invokeStartElement (pctxt, "adaptiveClockRecovery", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "adaptiveClockRecovery", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1_errorCorrection               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_errorCorrection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nullErrorCorrection */
+         case 0:
+            invokeStartElement (pctxt, "nullErrorCorrection", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "nullErrorCorrection", -1);
+
+            break;
+
+         /* longInterleaver */
+         case 1:
+            invokeStartElement (pctxt, "longInterleaver", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "longInterleaver", -1);
+
+            break;
+
+         /* shortInterleaver */
+         case 2:
+            invokeStartElement (pctxt, "shortInterleaver", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "shortInterleaver", -1);
+
+            break;
+
+         /* errorCorrectionOnly */
+         case 3:
+            invokeStartElement (pctxt, "errorCorrectionOnly", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "errorCorrectionOnly", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode clockRecovery */
+
+   invokeStartElement (pctxt, "clockRecovery", -1);
+
+   stat = asn1PD_H245NewATMVCIndication_aal_aal1_clockRecovery (pctxt, &pvalue->clockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "clockRecovery", -1);
+
+   /* decode errorCorrection */
+
+   invokeStartElement (pctxt, "errorCorrection", -1);
+
+   stat = asn1PD_H245NewATMVCIndication_aal_aal1_errorCorrection (pctxt, &pvalue->errorCorrection);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "errorCorrection", -1);
+
+   /* decode structuredDataTransfer */
+
+   invokeStartElement (pctxt, "structuredDataTransfer", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->structuredDataTransfer);
+
+   invokeEndElement (pctxt, "structuredDataTransfer", -1);
+
+   /* decode partiallyFilledCells */
+
+   invokeStartElement (pctxt, "partiallyFilledCells", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->partiallyFilledCells);
+
+   invokeEndElement (pctxt, "partiallyFilledCells", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal5                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal_aal5 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal5* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode forwardMaximumSDUSize */
+
+   invokeStartElement (pctxt, "forwardMaximumSDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->forwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->forwardMaximumSDUSize);
+
+   invokeEndElement (pctxt, "forwardMaximumSDUSize", -1);
+
+   /* decode backwardMaximumSDUSize */
+
+   invokeStartElement (pctxt, "backwardMaximumSDUSize", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->backwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->backwardMaximumSDUSize);
+
+   invokeEndElement (pctxt, "backwardMaximumSDUSize", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication_aal (OOCTXT* pctxt, H245NewATMVCIndication_aal* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* aal1 */
+         case 0:
+            invokeStartElement (pctxt, "aal1", -1);
+
+            pvalue->u.aal1 = ALLOC_ASN1ELEM (pctxt, H245NewATMVCIndication_aal_aal1);
+
+            stat = asn1PD_H245NewATMVCIndication_aal_aal1 (pctxt, pvalue->u.aal1);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "aal1", -1);
+
+            break;
+
+         /* aal5 */
+         case 1:
+            invokeStartElement (pctxt, "aal5", -1);
+
+            pvalue->u.aal5 = ALLOC_ASN1ELEM (pctxt, H245NewATMVCIndication_aal_aal5);
+
+            stat = asn1PD_H245NewATMVCIndication_aal_aal5 (pctxt, pvalue->u.aal5);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "aal5", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_multiplex                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_multiplex* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* noMultiplex */
+         case 0:
+            invokeStartElement (pctxt, "noMultiplex", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noMultiplex", -1);
+
+            break;
+
+         /* transportStream */
+         case 1:
+            invokeStartElement (pctxt, "transportStream", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transportStream", -1);
+
+            break;
+
+         /* programStream */
+         case 2:
+            invokeStartElement (pctxt, "programStream", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "programStream", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_reverseParameters_multiplex            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters_multiplex* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* noMultiplex */
+         case 0:
+            invokeStartElement (pctxt, "noMultiplex", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "noMultiplex", -1);
+
+            break;
+
+         /* transportStream */
+         case 1:
+            invokeStartElement (pctxt, "transportStream", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "transportStream", -1);
+
+            break;
+
+         /* programStream */
+         case 2:
+            invokeStartElement (pctxt, "programStream", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "programStream", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_reverseParameters                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication_reverseParameters (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   /* decode bitRateLockedToPCRClock */
+
+   invokeStartElement (pctxt, "bitRateLockedToPCRClock", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToPCRClock);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->bitRateLockedToPCRClock);
+
+   invokeEndElement (pctxt, "bitRateLockedToPCRClock", -1);
+
+   /* decode bitRateLockedToNetworkClock */
+
+   invokeStartElement (pctxt, "bitRateLockedToNetworkClock", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToNetworkClock);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->bitRateLockedToNetworkClock);
+
+   invokeEndElement (pctxt, "bitRateLockedToNetworkClock", -1);
+
+   /* decode multiplex */
+
+   invokeStartElement (pctxt, "multiplex", -1);
+
+   stat = asn1PD_H245NewATMVCIndication_reverseParameters_multiplex (pctxt, &pvalue->multiplex);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplex", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245NewATMVCIndication (OOCTXT* pctxt, H245NewATMVCIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   /* decode resourceID */
+
+   invokeStartElement (pctxt, "resourceID", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->resourceID, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->resourceID);
+
+   invokeEndElement (pctxt, "resourceID", -1);
+
+   /* decode bitRate */
+
+   invokeStartElement (pctxt, "bitRate", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->bitRate);
+
+   invokeEndElement (pctxt, "bitRate", -1);
+
+   /* decode bitRateLockedToPCRClock */
+
+   invokeStartElement (pctxt, "bitRateLockedToPCRClock", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToPCRClock);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->bitRateLockedToPCRClock);
+
+   invokeEndElement (pctxt, "bitRateLockedToPCRClock", -1);
+
+   /* decode bitRateLockedToNetworkClock */
+
+   invokeStartElement (pctxt, "bitRateLockedToNetworkClock", -1);
+
+   stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToNetworkClock);
+   if (stat != ASN_OK) return stat;
+   invokeBoolValue (pctxt, pvalue->bitRateLockedToNetworkClock);
+
+   invokeEndElement (pctxt, "bitRateLockedToNetworkClock", -1);
+
+   /* decode aal */
+
+   invokeStartElement (pctxt, "aal", -1);
+
+   stat = asn1PD_H245NewATMVCIndication_aal (pctxt, &pvalue->aal);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "aal", -1);
+
+   /* decode multiplex */
+
+   invokeStartElement (pctxt, "multiplex", -1);
+
+   stat = asn1PD_H245NewATMVCIndication_multiplex (pctxt, &pvalue->multiplex);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "multiplex", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.reverseParametersPresent = 1;
+
+                     invokeStartElement (pctxt, "reverseParameters", -1);
+
+                     stat = asn1PD_H245NewATMVCIndication_reverseParameters (pctxt, &pvalue->reverseParameters);
+                     if (stat != ASN_OK) return stat;
+
+                     invokeEndElement (pctxt, "reverseParameters", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_userInputSupportIndication            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UserInputIndication_userInputSupportIndication (OOCTXT* pctxt, H245UserInputIndication_userInputSupportIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* basicString */
+         case 1:
+            invokeStartElement (pctxt, "basicString", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "basicString", -1);
+
+            break;
+
+         /* iA5String */
+         case 2:
+            invokeStartElement (pctxt, "iA5String", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "iA5String", -1);
+
+            break;
+
+         /* generalString */
+         case 3:
+            invokeStartElement (pctxt, "generalString", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "generalString", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signal_rtp                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UserInputIndication_signal_rtp (OOCTXT* pctxt, H245UserInputIndication_signal_rtp* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.timestampPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.expirationTimePresent = optbit;
+
+   /* decode timestamp */
+
+   if (pvalue->m.timestampPresent) {
+      invokeStartElement (pctxt, "timestamp", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->timestamp, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->timestamp);
+
+      invokeEndElement (pctxt, "timestamp", -1);
+   }
+
+   /* decode expirationTime */
+
+   if (pvalue->m.expirationTimePresent) {
+      invokeStartElement (pctxt, "expirationTime", -1);
+
+      stat = decodeConsUnsigned (pctxt, &pvalue->expirationTime, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->expirationTime);
+
+      invokeEndElement (pctxt, "expirationTime", -1);
+   }
+
+   /* decode logicalChannelNumber */
+
+   invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signal                                */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet;
+
+EXTERN int asn1PD_H245UserInputIndication_signal (OOCTXT* pctxt, H245UserInputIndication_signal* pvalue)
+{
+   static Asn1SizeCnst signalType_lsize1 = { 0, 1, 1, 0 };
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   OOCTXT lctxt2;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.durationPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.rtpPresent = optbit;
+
+   /* decode signalType */
+
+   invokeStartElement (pctxt, "signalType", -1);
+
+   addSizeConstraint (pctxt, &signalType_lsize1);
+
+   stat = decodeConstrainedStringEx (pctxt, &pvalue->signalType, gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet, 8, 5, 7);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, pvalue->signalType);
+
+   invokeEndElement (pctxt, "signalType", -1);
+
+   /* decode duration */
+
+   if (pvalue->m.durationPresent) {
+      invokeStartElement (pctxt, "duration", -1);
+
+      stat = decodeConsUInt16 (pctxt, &pvalue->duration, 1U, 65535U);
+      if (stat != ASN_OK) return stat;
+      invokeUIntValue (pctxt, pvalue->duration);
+
+      invokeEndElement (pctxt, "duration", -1);
+   }
+
+   /* decode rtp */
+
+   if (pvalue->m.rtpPresent) {
+      invokeStartElement (pctxt, "rtp", -1);
+
+      stat = asn1PD_H245UserInputIndication_signal_rtp (pctxt, &pvalue->rtp);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "rtp", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            if (i < 1 && openType.numocts > 0) {  /* known element */
+               copyContext (&lctxt2, pctxt);
+               initContextBuffer (pctxt, openType.data, openType.numocts);
+
+               switch (i) {
+                  case 0:
+                     pvalue->m.rtpPayloadIndicationPresent = 1;
+
+                     invokeStartElement (pctxt, "rtpPayloadIndication", -1);
+
+                     /* NULL */
+                     invokeNullValue (pctxt);
+
+                     invokeEndElement (pctxt, "rtpPayloadIndication", -1);
+                     break;
+
+                  default:
+                     pctxt->buffer.byteIndex += openType.numocts;
+               }
+               copyContext (pctxt, &lctxt2);
+            }
+            else {  /* unknown element */
+               pctxt->buffer.byteIndex += openType.numocts;
+            }
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signalUpdate_rtp                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UserInputIndication_signalUpdate_rtp (OOCTXT* pctxt, H245UserInputIndication_signalUpdate_rtp* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode logicalChannelNumber */
+
+   invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signalUpdate                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UserInputIndication_signalUpdate (OOCTXT* pctxt, H245UserInputIndication_signalUpdate* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.rtpPresent = optbit;
+
+   /* decode duration */
+
+   invokeStartElement (pctxt, "duration", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->duration, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->duration);
+
+   invokeEndElement (pctxt, "duration", -1);
+
+   /* decode rtp */
+
+   if (pvalue->m.rtpPresent) {
+      invokeStartElement (pctxt, "rtp", -1);
+
+      stat = asn1PD_H245UserInputIndication_signalUpdate_rtp (pctxt, &pvalue->rtp);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "rtp", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_extendedAlphanumeric                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UserInputIndication_extendedAlphanumeric (OOCTXT* pctxt, H245UserInputIndication_extendedAlphanumeric* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.rtpPayloadIndicationPresent = optbit;
+
+   /* decode alphanumeric */
+
+   invokeStartElement (pctxt, "alphanumeric", -1);
+
+   stat = decodeVarWidthCharString (pctxt, &pvalue->alphanumeric);
+   if (stat != ASN_OK) return stat;
+   invokeCharStrValue (pctxt, pvalue->alphanumeric);
+
+   invokeEndElement (pctxt, "alphanumeric", -1);
+
+   /* decode rtpPayloadIndication */
+
+   if (pvalue->m.rtpPayloadIndicationPresent) {
+      invokeStartElement (pctxt, "rtpPayloadIndication", -1);
+
+      /* NULL */
+      invokeNullValue (pctxt);
+
+      invokeEndElement (pctxt, "rtpPayloadIndication", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245UserInputIndication (OOCTXT* pctxt, H245UserInputIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
+
+            stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* alphanumeric */
+         case 1:
+            invokeStartElement (pctxt, "alphanumeric", -1);
+
+            stat = decodeVarWidthCharString (pctxt, &pvalue->u.alphanumeric);
+            if (stat != ASN_OK) return stat;
+            invokeCharStrValue (pctxt, pvalue->u.alphanumeric);
+
+            invokeEndElement (pctxt, "alphanumeric", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 3;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* userInputSupportIndication */
+         case 3:
+            invokeStartElement (pctxt, "userInputSupportIndication", -1);
+
+            pvalue->u.userInputSupportIndication = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication_userInputSupportIndication);
+
+            stat = asn1PD_H245UserInputIndication_userInputSupportIndication (pctxt, pvalue->u.userInputSupportIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "userInputSupportIndication", -1);
+
+            break;
+
+         /* signal */
+         case 4:
+            invokeStartElement (pctxt, "signal", -1);
+
+            pvalue->u.signal = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication_signal);
+
+            stat = asn1PD_H245UserInputIndication_signal (pctxt, pvalue->u.signal);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "signal", -1);
+
+            break;
+
+         /* signalUpdate */
+         case 5:
+            invokeStartElement (pctxt, "signalUpdate", -1);
+
+            pvalue->u.signalUpdate = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication_signalUpdate);
+
+            stat = asn1PD_H245UserInputIndication_signalUpdate (pctxt, pvalue->u.signalUpdate);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "signalUpdate", -1);
+
+            break;
+
+         /* extendedAlphanumeric */
+         case 6:
+            invokeStartElement (pctxt, "extendedAlphanumeric", -1);
+
+            pvalue->u.extendedAlphanumeric = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication_extendedAlphanumeric);
+
+            stat = asn1PD_H245UserInputIndication_extendedAlphanumeric (pctxt, pvalue->u.extendedAlphanumeric);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "extendedAlphanumeric", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250MaximumSkewIndication                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245H2250MaximumSkewIndication (OOCTXT* pctxt, H245H2250MaximumSkewIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode logicalChannelNumber1 */
+
+   invokeStartElement (pctxt, "logicalChannelNumber1", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber1);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber1", -1);
+
+   /* decode logicalChannelNumber2 */
+
+   invokeStartElement (pctxt, "logicalChannelNumber2", -1);
+
+   stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber2);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "logicalChannelNumber2", -1);
+
+   /* decode maximumSkew */
+
+   invokeStartElement (pctxt, "maximumSkew", -1);
+
+   stat = decodeConsUInt16 (pctxt, &pvalue->maximumSkew, 0U, 4095U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->maximumSkew);
+
+   invokeEndElement (pctxt, "maximumSkew", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MCLocationIndication                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MCLocationIndication (OOCTXT* pctxt, H245MCLocationIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode signalAddress */
+
+   invokeStartElement (pctxt, "signalAddress", -1);
+
+   stat = asn1PD_H245TransportAddress (pctxt, &pvalue->signalAddress);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "signalAddress", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalYouAreSeeingInSubPictureNumber                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245TerminalYouAreSeeingInSubPictureNumber (OOCTXT* pctxt, H245TerminalYouAreSeeingInSubPictureNumber* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode terminalNumber */
+
+   invokeStartElement (pctxt, "terminalNumber", -1);
+
+   stat = asn1PD_H245TerminalNumber (pctxt, &pvalue->terminalNumber);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "terminalNumber", -1);
+
+   /* decode subPictureNumber */
+
+   invokeStartElement (pctxt, "subPictureNumber", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->subPictureNumber, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->subPictureNumber);
+
+   invokeEndElement (pctxt, "subPictureNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VideoIndicateCompose                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VideoIndicateCompose (OOCTXT* pctxt, H245VideoIndicateCompose* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode compositionNumber */
+
+   invokeStartElement (pctxt, "compositionNumber", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->compositionNumber, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->compositionNumber);
+
+   invokeEndElement (pctxt, "compositionNumber", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceIndication                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245ConferenceIndication (OOCTXT* pctxt, H245ConferenceIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 9);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* sbeNumber */
+         case 0:
+            invokeStartElement (pctxt, "sbeNumber", -1);
+
+            stat = decodeConsUInt8 (pctxt, &pvalue->u.sbeNumber, 0U, 9U);
+            if (stat != ASN_OK) return stat;
+            invokeUIntValue (pctxt, pvalue->u.sbeNumber);
+
+            invokeEndElement (pctxt, "sbeNumber", -1);
+
+            break;
+
+         /* terminalNumberAssign */
+         case 1:
+            invokeStartElement (pctxt, "terminalNumberAssign", -1);
+
+            pvalue->u.terminalNumberAssign = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.terminalNumberAssign);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalNumberAssign", -1);
+
+            break;
+
+         /* terminalJoinedConference */
+         case 2:
+            invokeStartElement (pctxt, "terminalJoinedConference", -1);
+
+            pvalue->u.terminalJoinedConference = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.terminalJoinedConference);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalJoinedConference", -1);
+
+            break;
+
+         /* terminalLeftConference */
+         case 3:
+            invokeStartElement (pctxt, "terminalLeftConference", -1);
+
+            pvalue->u.terminalLeftConference = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.terminalLeftConference);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalLeftConference", -1);
+
+            break;
+
+         /* seenByAtLeastOneOther */
+         case 4:
+            invokeStartElement (pctxt, "seenByAtLeastOneOther", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "seenByAtLeastOneOther", -1);
+
+            break;
+
+         /* cancelSeenByAtLeastOneOther */
+         case 5:
+            invokeStartElement (pctxt, "cancelSeenByAtLeastOneOther", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelSeenByAtLeastOneOther", -1);
+
+            break;
+
+         /* seenByAll */
+         case 6:
+            invokeStartElement (pctxt, "seenByAll", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "seenByAll", -1);
+
+            break;
+
+         /* cancelSeenByAll */
+         case 7:
+            invokeStartElement (pctxt, "cancelSeenByAll", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "cancelSeenByAll", -1);
+
+            break;
+
+         /* terminalYouAreSeeing */
+         case 8:
+            invokeStartElement (pctxt, "terminalYouAreSeeing", -1);
+
+            pvalue->u.terminalYouAreSeeing = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.terminalYouAreSeeing);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalYouAreSeeing", -1);
+
+            break;
+
+         /* requestForFloor */
+         case 9:
+            invokeStartElement (pctxt, "requestForFloor", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "requestForFloor", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 11;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* withdrawChairToken */
+         case 11:
+            invokeStartElement (pctxt, "withdrawChairToken", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "withdrawChairToken", -1);
+
+            break;
+
+         /* floorRequested */
+         case 12:
+            invokeStartElement (pctxt, "floorRequested", -1);
+
+            pvalue->u.floorRequested = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel);
+
+            stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.floorRequested);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "floorRequested", -1);
+
+            break;
+
+         /* terminalYouAreSeeingInSubPictureNumber */
+         case 13:
+            invokeStartElement (pctxt, "terminalYouAreSeeingInSubPictureNumber", -1);
+
+            pvalue->u.terminalYouAreSeeingInSubPictureNumber = ALLOC_ASN1ELEM (pctxt, H245TerminalYouAreSeeingInSubPictureNumber);
+
+            stat = asn1PD_H245TerminalYouAreSeeingInSubPictureNumber (pctxt, pvalue->u.terminalYouAreSeeingInSubPictureNumber);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalYouAreSeeingInSubPictureNumber", -1);
+
+            break;
+
+         /* videoIndicateCompose */
+         case 14:
+            invokeStartElement (pctxt, "videoIndicateCompose", -1);
+
+            pvalue->u.videoIndicateCompose = ALLOC_ASN1ELEM (pctxt, H245VideoIndicateCompose);
+
+            stat = asn1PD_H245VideoIndicateCompose (pctxt, pvalue->u.videoIndicateCompose);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "videoIndicateCompose", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification_productNumber                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VendorIdentification_productNumber (OOCTXT* pctxt, H245VendorIdentification_productNumber* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification_versionNumber                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VendorIdentification_versionNumber (OOCTXT* pctxt, H245VendorIdentification_versionNumber* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = decodeOctetString (pctxt,
+                          &pvalue->numocts,
+                          pvalue->data,
+                          sizeof(pvalue->data));
+   if (stat != ASN_OK) return stat;
+   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245VendorIdentification (OOCTXT* pctxt, H245VendorIdentification* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.productNumberPresent = optbit;
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.versionNumberPresent = optbit;
+
+   /* decode vendor */
+
+   invokeStartElement (pctxt, "vendor", -1);
+
+   stat = asn1PD_H245NonStandardIdentifier (pctxt, &pvalue->vendor);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "vendor", -1);
+
+   /* decode productNumber */
+
+   if (pvalue->m.productNumberPresent) {
+      invokeStartElement (pctxt, "productNumber", -1);
+
+      stat = asn1PD_H245VendorIdentification_productNumber (pctxt, &pvalue->productNumber);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "productNumber", -1);
+   }
+
+   /* decode versionNumber */
+
+   if (pvalue->m.versionNumberPresent) {
+      invokeStartElement (pctxt, "versionNumber", -1);
+
+      stat = asn1PD_H245VendorIdentification_versionNumber (pctxt, &pvalue->versionNumber);
+      if (stat != ASN_OK) return stat;
+
+      invokeEndElement (pctxt, "versionNumber", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotSupported_cause                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FunctionNotSupported_cause (OOCTXT* pctxt, H245FunctionNotSupported_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* syntaxError */
+         case 0:
+            invokeStartElement (pctxt, "syntaxError", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "syntaxError", -1);
+
+            break;
+
+         /* semanticError */
+         case 1:
+            invokeStartElement (pctxt, "semanticError", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "semanticError", -1);
+
+            break;
+
+         /* unknownFunction */
+         case 2:
+            invokeStartElement (pctxt, "unknownFunction", -1);
+
+            /* NULL */
+            invokeNullValue (pctxt);
+
+            invokeEndElement (pctxt, "unknownFunction", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotSupported                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FunctionNotSupported (OOCTXT* pctxt, H245FunctionNotSupported* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* optional bits */
+
+   memset (&pvalue->m, 0, sizeof(pvalue->m));
+
+   DECODEBIT (pctxt, &optbit);
+   pvalue->m.returnedFunctionPresent = optbit;
+
+   /* decode cause */
+
+   invokeStartElement (pctxt, "cause", -1);
+
+   stat = asn1PD_H245FunctionNotSupported_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "cause", -1);
+
+   /* decode returnedFunction */
+
+   if (pvalue->m.returnedFunctionPresent) {
+      invokeStartElement (pctxt, "returnedFunction", -1);
+
+      stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->returnedFunction);
+      if (stat != ASN_OK) return stat;
+      invokeOctStrValue (pctxt, pvalue->returnedFunction.numocts, pvalue->returnedFunction.data);
+
+      invokeEndElement (pctxt, "returnedFunction", -1);
+   }
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication_crcDesired                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkIndication_crcDesired (OOCTXT* pctxt, H245MultilinkIndication_crcDesired* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication_excessiveError                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkIndication_excessiveError (OOCTXT* pctxt, H245MultilinkIndication_excessiveError* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode connectionIdentifier */
+
+   invokeStartElement (pctxt, "connectionIdentifier", -1);
+
+   stat = asn1PD_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "connectionIdentifier", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultilinkIndication (OOCTXT* pctxt, H245MultilinkIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* crcDesired */
+         case 1:
+            invokeStartElement (pctxt, "crcDesired", -1);
+
+            pvalue->u.crcDesired = ALLOC_ASN1ELEM (pctxt, H245MultilinkIndication_crcDesired);
+
+            stat = asn1PD_H245MultilinkIndication_crcDesired (pctxt, pvalue->u.crcDesired);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "crcDesired", -1);
+
+            break;
+
+         /* excessiveError */
+         case 2:
+            invokeStartElement (pctxt, "excessiveError", -1);
+
+            pvalue->u.excessiveError = ALLOC_ASN1ELEM (pctxt, H245MultilinkIndication_excessiveError);
+
+            stat = asn1PD_H245MultilinkIndication_excessiveError (pctxt, pvalue->u.excessiveError);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "excessiveError", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 4;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRelease                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245LogicalChannelRateRelease (OOCTXT* pctxt, H245LogicalChannelRateRelease* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication_scope                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FlowControlIndication_scope (OOCTXT* pctxt, H245FlowControlIndication_scope* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* logicalChannelNumber */
+      case 0:
+         invokeStartElement (pctxt, "logicalChannelNumber", -1);
+
+         stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelNumber);
+         if (stat != ASN_OK) return stat;
+
+         invokeEndElement (pctxt, "logicalChannelNumber", -1);
+
+         break;
+
+      /* resourceID */
+      case 1:
+         invokeStartElement (pctxt, "resourceID", -1);
+
+         stat = decodeConsUInt16 (pctxt, &pvalue->u.resourceID, 0U, 65535U);
+         if (stat != ASN_OK) return stat;
+         invokeUIntValue (pctxt, pvalue->u.resourceID);
+
+         invokeEndElement (pctxt, "resourceID", -1);
+
+         break;
+
+      /* wholeMultiplex */
+      case 2:
+         invokeStartElement (pctxt, "wholeMultiplex", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "wholeMultiplex", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication_restriction                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FlowControlIndication_restriction (OOCTXT* pctxt, H245FlowControlIndication_restriction* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+
+   stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
+   if (stat != ASN_OK) return stat;
+   else pvalue->t = ui + 1;
+
+   switch (ui) {
+      /* maximumBitRate */
+      case 0:
+         invokeStartElement (pctxt, "maximumBitRate", -1);
+
+         stat = decodeConsUnsigned (pctxt, &pvalue->u.maximumBitRate, 0U, 16777215U);
+         if (stat != ASN_OK) return stat;
+         invokeUIntValue (pctxt, pvalue->u.maximumBitRate);
+
+         invokeEndElement (pctxt, "maximumBitRate", -1);
+
+         break;
+
+      /* noRestriction */
+      case 1:
+         invokeStartElement (pctxt, "noRestriction", -1);
+
+         /* NULL */
+         invokeNullValue (pctxt);
+
+         invokeEndElement (pctxt, "noRestriction", -1);
+
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245FlowControlIndication (OOCTXT* pctxt, H245FlowControlIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode scope */
+
+   invokeStartElement (pctxt, "scope", -1);
+
+   stat = asn1PD_H245FlowControlIndication_scope (pctxt, &pvalue->scope);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "scope", -1);
+
+   /* decode restriction */
+
+   invokeStartElement (pctxt, "restriction", -1);
+
+   stat = asn1PD_H245FlowControlIndication_restriction (pctxt, &pvalue->restriction);
+   if (stat != ASN_OK) return stat;
+
+   invokeEndElement (pctxt, "restriction", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationIndication                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MobileMultilinkReconfigurationIndication (OOCTXT* pctxt, H245MobileMultilinkReconfigurationIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1UINT bitcnt;
+   ASN1UINT i;
+   ASN1BOOL optbit;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   /* decode sampleSize */
+
+   invokeStartElement (pctxt, "sampleSize", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->sampleSize, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->sampleSize);
+
+   invokeEndElement (pctxt, "sampleSize", -1);
+
+   /* decode samplesPerFrame */
+
+   invokeStartElement (pctxt, "samplesPerFrame", -1);
+
+   stat = decodeConsUInt8 (pctxt, &pvalue->samplesPerFrame, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+   invokeUIntValue (pctxt, pvalue->samplesPerFrame);
+
+   invokeEndElement (pctxt, "samplesPerFrame", -1);
+
+   if (extbit) {
+
+      /* decode extension optional bits length */
+
+      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      bitcnt += 1;
+
+      ZEROCONTEXT (&lctxt);
+      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = moveBitCursor (pctxt, bitcnt);
+      if (stat != ASN_OK) return stat;
+
+      for (i = 0; i < bitcnt; i++) {
+         DECODEBIT (&lctxt, &optbit);
+
+         if (optbit) {
+            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+            if (stat != ASN_OK) return stat;
+
+            pctxt->buffer.byteIndex += openType.numocts;
+         }
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IndicationMessage                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245IndicationMessage (OOCTXT* pctxt, H245IndicationMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 13);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* nonStandard */
+         case 0:
+            invokeStartElement (pctxt, "nonStandard", -1);
+
+            pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage);
+
+            stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "nonStandard", -1);
+
+            break;
+
+         /* functionNotUnderstood */
+         case 1:
+            invokeStartElement (pctxt, "functionNotUnderstood", -1);
+
+            pvalue->u.functionNotUnderstood = ALLOC_ASN1ELEM (pctxt, H245FunctionNotUnderstood);
+
+            stat = asn1PD_H245FunctionNotUnderstood (pctxt, pvalue->u.functionNotUnderstood);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "functionNotUnderstood", -1);
+
+            break;
+
+         /* masterSlaveDeterminationRelease */
+         case 2:
+            invokeStartElement (pctxt, "masterSlaveDeterminationRelease", -1);
+
+            pvalue->u.masterSlaveDeterminationRelease = ALLOC_ASN1ELEM (pctxt, H245MasterSlaveDeterminationRelease);
+
+            stat = asn1PD_H245MasterSlaveDeterminationRelease (pctxt, pvalue->u.masterSlaveDeterminationRelease);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "masterSlaveDeterminationRelease", -1);
+
+            break;
+
+         /* terminalCapabilitySetRelease */
+         case 3:
+            invokeStartElement (pctxt, "terminalCapabilitySetRelease", -1);
+
+            pvalue->u.terminalCapabilitySetRelease = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySetRelease);
+
+            stat = asn1PD_H245TerminalCapabilitySetRelease (pctxt, pvalue->u.terminalCapabilitySetRelease);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "terminalCapabilitySetRelease", -1);
+
+            break;
+
+         /* openLogicalChannelConfirm */
+         case 4:
+            invokeStartElement (pctxt, "openLogicalChannelConfirm", -1);
+
+            pvalue->u.openLogicalChannelConfirm = ALLOC_ASN1ELEM (pctxt, H245OpenLogicalChannelConfirm);
+
+            stat = asn1PD_H245OpenLogicalChannelConfirm (pctxt, pvalue->u.openLogicalChannelConfirm);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "openLogicalChannelConfirm", -1);
+
+            break;
+
+         /* requestChannelCloseRelease */
+         case 5:
+            invokeStartElement (pctxt, "requestChannelCloseRelease", -1);
+
+            pvalue->u.requestChannelCloseRelease = ALLOC_ASN1ELEM (pctxt, H245RequestChannelCloseRelease);
+
+            stat = asn1PD_H245RequestChannelCloseRelease (pctxt, pvalue->u.requestChannelCloseRelease);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestChannelCloseRelease", -1);
+
+            break;
+
+         /* multiplexEntrySendRelease */
+         case 6:
+            invokeStartElement (pctxt, "multiplexEntrySendRelease", -1);
+
+            pvalue->u.multiplexEntrySendRelease = ALLOC_ASN1ELEM (pctxt, H245MultiplexEntrySendRelease);
+
+            stat = asn1PD_H245MultiplexEntrySendRelease (pctxt, pvalue->u.multiplexEntrySendRelease);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multiplexEntrySendRelease", -1);
+
+            break;
+
+         /* requestMultiplexEntryRelease */
+         case 7:
+            invokeStartElement (pctxt, "requestMultiplexEntryRelease", -1);
+
+            pvalue->u.requestMultiplexEntryRelease = ALLOC_ASN1ELEM (pctxt, H245RequestMultiplexEntryRelease);
+
+            stat = asn1PD_H245RequestMultiplexEntryRelease (pctxt, pvalue->u.requestMultiplexEntryRelease);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestMultiplexEntryRelease", -1);
+
+            break;
+
+         /* requestModeRelease */
+         case 8:
+            invokeStartElement (pctxt, "requestModeRelease", -1);
+
+            pvalue->u.requestModeRelease = ALLOC_ASN1ELEM (pctxt, H245RequestModeRelease);
+
+            stat = asn1PD_H245RequestModeRelease (pctxt, pvalue->u.requestModeRelease);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "requestModeRelease", -1);
+
+            break;
+
+         /* miscellaneousIndication */
+         case 9:
+            invokeStartElement (pctxt, "miscellaneousIndication", -1);
+
+            pvalue->u.miscellaneousIndication = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousIndication);
+
+            stat = asn1PD_H245MiscellaneousIndication (pctxt, pvalue->u.miscellaneousIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "miscellaneousIndication", -1);
+
+            break;
+
+         /* jitterIndication */
+         case 10:
+            invokeStartElement (pctxt, "jitterIndication", -1);
+
+            pvalue->u.jitterIndication = ALLOC_ASN1ELEM (pctxt, H245JitterIndication);
+
+            stat = asn1PD_H245JitterIndication (pctxt, pvalue->u.jitterIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "jitterIndication", -1);
+
+            break;
+
+         /* h223SkewIndication */
+         case 11:
+            invokeStartElement (pctxt, "h223SkewIndication", -1);
+
+            pvalue->u.h223SkewIndication = ALLOC_ASN1ELEM (pctxt, H245H223SkewIndication);
+
+            stat = asn1PD_H245H223SkewIndication (pctxt, pvalue->u.h223SkewIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h223SkewIndication", -1);
+
+            break;
+
+         /* newATMVCIndication */
+         case 12:
+            invokeStartElement (pctxt, "newATMVCIndication", -1);
+
+            pvalue->u.newATMVCIndication = ALLOC_ASN1ELEM (pctxt, H245NewATMVCIndication);
+
+            stat = asn1PD_H245NewATMVCIndication (pctxt, pvalue->u.newATMVCIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "newATMVCIndication", -1);
+
+            break;
+
+         /* userInput */
+         case 13:
+            invokeStartElement (pctxt, "userInput", -1);
+
+            pvalue->u.userInput = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication);
+
+            stat = asn1PD_H245UserInputIndication (pctxt, pvalue->u.userInput);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "userInput", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 15;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+      copyContext (&lctxt, pctxt);
+      initContextBuffer (pctxt, openType.data, openType.numocts);
+
+      switch (pvalue->t) {
+         /* h2250MaximumSkewIndication */
+         case 15:
+            invokeStartElement (pctxt, "h2250MaximumSkewIndication", -1);
+
+            pvalue->u.h2250MaximumSkewIndication = ALLOC_ASN1ELEM (pctxt, H245H2250MaximumSkewIndication);
+
+            stat = asn1PD_H245H2250MaximumSkewIndication (pctxt, pvalue->u.h2250MaximumSkewIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "h2250MaximumSkewIndication", -1);
+
+            break;
+
+         /* mcLocationIndication */
+         case 16:
+            invokeStartElement (pctxt, "mcLocationIndication", -1);
+
+            pvalue->u.mcLocationIndication = ALLOC_ASN1ELEM (pctxt, H245MCLocationIndication);
+
+            stat = asn1PD_H245MCLocationIndication (pctxt, pvalue->u.mcLocationIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "mcLocationIndication", -1);
+
+            break;
+
+         /* conferenceIndication */
+         case 17:
+            invokeStartElement (pctxt, "conferenceIndication", -1);
+
+            pvalue->u.conferenceIndication = ALLOC_ASN1ELEM (pctxt, H245ConferenceIndication);
+
+            stat = asn1PD_H245ConferenceIndication (pctxt, pvalue->u.conferenceIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "conferenceIndication", -1);
+
+            break;
+
+         /* vendorIdentification */
+         case 18:
+            invokeStartElement (pctxt, "vendorIdentification", -1);
+
+            pvalue->u.vendorIdentification = ALLOC_ASN1ELEM (pctxt, H245VendorIdentification);
+
+            stat = asn1PD_H245VendorIdentification (pctxt, pvalue->u.vendorIdentification);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "vendorIdentification", -1);
+
+            break;
+
+         /* functionNotSupported */
+         case 19:
+            invokeStartElement (pctxt, "functionNotSupported", -1);
+
+            pvalue->u.functionNotSupported = ALLOC_ASN1ELEM (pctxt, H245FunctionNotSupported);
+
+            stat = asn1PD_H245FunctionNotSupported (pctxt, pvalue->u.functionNotSupported);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "functionNotSupported", -1);
+
+            break;
+
+         /* multilinkIndication */
+         case 20:
+            invokeStartElement (pctxt, "multilinkIndication", -1);
+
+            pvalue->u.multilinkIndication = ALLOC_ASN1ELEM (pctxt, H245MultilinkIndication);
+
+            stat = asn1PD_H245MultilinkIndication (pctxt, pvalue->u.multilinkIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "multilinkIndication", -1);
+
+            break;
+
+         /* logicalChannelRateRelease */
+         case 21:
+            invokeStartElement (pctxt, "logicalChannelRateRelease", -1);
+
+            pvalue->u.logicalChannelRateRelease = ALLOC_ASN1ELEM (pctxt, H245LogicalChannelRateRelease);
+
+            stat = asn1PD_H245LogicalChannelRateRelease (pctxt, pvalue->u.logicalChannelRateRelease);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "logicalChannelRateRelease", -1);
+
+            break;
+
+         /* flowControlIndication */
+         case 22:
+            invokeStartElement (pctxt, "flowControlIndication", -1);
+
+            pvalue->u.flowControlIndication = ALLOC_ASN1ELEM (pctxt, H245FlowControlIndication);
+
+            stat = asn1PD_H245FlowControlIndication (pctxt, pvalue->u.flowControlIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "flowControlIndication", -1);
+
+            break;
+
+         /* mobileMultilinkReconfigurationIndication */
+         case 23:
+            invokeStartElement (pctxt, "mobileMultilinkReconfigurationIndication", -1);
+
+            pvalue->u.mobileMultilinkReconfigurationIndication = ALLOC_ASN1ELEM (pctxt, H245MobileMultilinkReconfigurationIndication);
+
+            stat = asn1PD_H245MobileMultilinkReconfigurationIndication (pctxt, pvalue->u.mobileMultilinkReconfigurationIndication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "mobileMultilinkReconfigurationIndication", -1);
+
+            break;
+
+         default:;
+      }
+
+      copyContext (pctxt, &lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultimediaSystemControlMessage                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PD_H245MultimediaSystemControlMessage (OOCTXT* pctxt, H245MultimediaSystemControlMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT ui;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   DECODEBIT (pctxt, &extbit);
+
+   if (!extbit) {
+      stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 1;
+
+      switch (ui) {
+         /* request */
+         case 0:
+            invokeStartElement (pctxt, "request", -1);
+
+            pvalue->u.request = ALLOC_ASN1ELEM (pctxt, H245RequestMessage);
+
+            stat = asn1PD_H245RequestMessage (pctxt, pvalue->u.request);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "request", -1);
+
+            break;
+
+         /* response */
+         case 1:
+            invokeStartElement (pctxt, "response", -1);
+
+            pvalue->u.response = ALLOC_ASN1ELEM (pctxt, H245ResponseMessage);
+
+            stat = asn1PD_H245ResponseMessage (pctxt, pvalue->u.response);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "response", -1);
+
+            break;
+
+         /* command */
+         case 2:
+            invokeStartElement (pctxt, "command", -1);
+
+            pvalue->u.command = ALLOC_ASN1ELEM (pctxt, H245CommandMessage);
+
+            stat = asn1PD_H245CommandMessage (pctxt, pvalue->u.command);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "command", -1);
+
+            break;
+
+         /* indication */
+         case 3:
+            invokeStartElement (pctxt, "indication", -1);
+
+            pvalue->u.indication = ALLOC_ASN1ELEM (pctxt, H245IndicationMessage);
+
+            stat = asn1PD_H245IndicationMessage (pctxt, pvalue->u.indication);
+            if (stat != ASN_OK) return stat;
+
+            invokeEndElement (pctxt, "indication", -1);
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
+      if (stat != ASN_OK) return stat;
+      else pvalue->t = ui + 5;
+
+      stat = decodeByteAlign (pctxt);
+      if (stat != ASN_OK) return stat;
+
+      stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
diff --git a/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c
new file mode 100644
index 000000000..ac124d96d
--- /dev/null
+++ b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c
@@ -0,0 +1,26599 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * This file was generated by the Objective Systems ASN1C Compiler
+ * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
+ */
+#include "ooasn1.h"
+#include "MULTIMEDIA-SYSTEM-CONTROL.h"
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier_h221NonStandard                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode t35CountryCode */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t35CountryCode, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode t35Extension */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t35Extension, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode manufacturerCode */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->manufacturerCode, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardIdentifier                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* 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)
+   {
+      /* object */
+      case 1:
+         stat = encodeObjectIdentifier (pctxt, pvalue->u.object);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      /* h221NonStandard */
+      case 2:
+         stat = asn1PE_H245NonStandardIdentifier_h221NonStandard (pctxt, pvalue->u.h221NonStandard);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardParameter                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode nonStandardIdentifier */
+
+   stat = asn1PE_H245NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode data */
+
+   stat = encodeOctetString (pctxt, pvalue->data.numocts, pvalue->data.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V42bis                                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode numberOfCodewords */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfCodewords, 1U, 65536U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maximumStringLength */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maximumStringLength, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CompressionType                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* v42bis */
+         case 1:
+            stat = asn1PE_H245V42bis (pctxt, pvalue->u.v42bis);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataProtocolCapability_v76wCompression                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* transmitCompression */
+         case 1:
+            stat = asn1PE_H245CompressionType (pctxt, pvalue->u.transmitCompression);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* receiveCompression */
+         case 2:
+            stat = asn1PE_H245CompressionType (pctxt, pvalue->u.receiveCompression);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* transmitAndReceiveCompression */
+         case 3:
+            stat = asn1PE_H245CompressionType (pctxt, pvalue->u.transmitAndReceiveCompression);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataProtocolCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 7);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* v14buffered */
+         case 2:
+            /* NULL */
+            break;
+
+         /* v42lapm */
+         case 3:
+            /* NULL */
+            break;
+
+         /* hdlcFrameTunnelling */
+         case 4:
+            /* NULL */
+            break;
+
+         /* h310SeparateVCStack */
+         case 5:
+            /* NULL */
+            break;
+
+         /* h310SingleVCStack */
+         case 6:
+            /* NULL */
+            break;
+
+         /* transparent */
+         case 7:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* segmentationAndReassembly */
+         case 8:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* hdlcFrameTunnelingwSAR */
+         case 9:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* v120 */
+         case 10:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* separateLANStack */
+         case 11:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* v76wCompression */
+         case 12:
+            stat = asn1PE_H245DataProtocolCapability_v76wCompression (&lctxt, pvalue->u.v76wCompression);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* tcp */
+         case 13:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* udp */
+         case 14:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxRateManagement                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* localTCF */
+         case 1:
+            /* NULL */
+            break;
+
+         /* transferredTCF */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxUdpOptions_t38FaxUdpEC                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* t38UDPFEC */
+         case 1:
+            /* NULL */
+            break;
+
+         /* t38UDPRedundancy */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxUdpOptions                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue)
+{
+   int stat = ASN_OK;
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxMaxBufferPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxMaxDatagramPresent);
+
+   /* encode t38FaxMaxBuffer */
+
+   if (pvalue->m.t38FaxMaxBufferPresent) {
+      stat = encodeUnconsInteger (pctxt, pvalue->t38FaxMaxBuffer);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode t38FaxMaxDatagram */
+
+   if (pvalue->m.t38FaxMaxDatagramPresent) {
+      stat = encodeUnconsInteger (pctxt, pvalue->t38FaxMaxDatagram);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode t38FaxUdpEC */
+
+   stat = asn1PE_H245T38FaxUdpOptions_t38FaxUdpEC (pctxt, &pvalue->t38FaxUdpEC);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxTcpOptions                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode t38TCPBidirectionalMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->t38TCPBidirectionalMode);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T38FaxProfile                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.versionPresent ||
+   pvalue->m.t38FaxRateManagementPresent ||
+   pvalue->m.t38FaxUdpOptionsPresent ||
+   pvalue->m.t38FaxTcpOptionsPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode fillBitRemoval */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fillBitRemoval);
+   if (stat != ASN_OK) return stat;
+
+   /* encode transcodingJBIG */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->transcodingJBIG);
+   if (stat != ASN_OK) return stat;
+
+   /* encode transcodingMMR */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->transcodingMMR);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.versionPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxRateManagementPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxUdpOptionsPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxTcpOptionsPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.versionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->version, 0U, 255U);
+         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.t38FaxRateManagementPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245T38FaxRateManagement (&lctxt, &pvalue->t38FaxRateManagement);
+         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.t38FaxUdpOptionsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245T38FaxUdpOptions (&lctxt, &pvalue->t38FaxUdpOptions);
+         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.t38FaxTcpOptionsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245T38FaxTcpOptions (&lctxt, &pvalue->t38FaxTcpOptions);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NonStandardMessage                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode nonStandardData */
+
+   stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandardData);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDetermination                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalType */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->terminalType, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode statusDeterminationNumber */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->statusDeterminationNumber, 0U, 16777215U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SequenceNumber                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode nullClockRecovery */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nullClockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   /* encode srtsClockRecovery */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->srtsClockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   /* encode adaptiveClockRecovery */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->adaptiveClockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nullErrorCorrection */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nullErrorCorrection);
+   if (stat != ASN_OK) return stat;
+
+   /* encode longInterleaver */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->longInterleaver);
+   if (stat != ASN_OK) return stat;
+
+   /* encode shortInterleaver */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->shortInterleaver);
+   if (stat != ASN_OK) return stat;
+
+   /* encode errorCorrectionOnly */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->errorCorrectionOnly);
+   if (stat != ASN_OK) return stat;
+
+   /* encode structuredDataTransfer */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->structuredDataTransfer);
+   if (stat != ASN_OK) return stat;
+
+   /* encode partiallyFilledCells */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partiallyFilledCells);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal5                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardMaximumSDUSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->forwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode backwardMaximumSDUSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->backwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates_type_rangeOfBitRates       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode lowerBitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->lowerBitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode higherBitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->higherBitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates_type                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* 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)
+   {
+      /* singleBitRate */
+      case 1:
+         stat = encodeConsUnsigned (pctxt, pvalue->u.singleBitRate, 1U, 65535U);
+         if (stat != ASN_OK) return stat;
+
+         break;
+
+      /* rangeOfBitRates */
+      case 2:
+         stat = asn1PE_H245VCCapability_availableBitRates_type_rangeOfBitRates (pctxt, pvalue->u.rangeOfBitRates);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_availableBitRates                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = asn1PE_H245VCCapability_availableBitRates_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_address_nsapAddress                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_address                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue)
+{
+   static Asn1SizeCnst internationalNumber_lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* internationalNumber */
+         case 1:
+            addSizeConstraint (pctxt, &internationalNumber_lsize1);
+
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.internationalNumber, NUM_CANSET, 4, 4, 4);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nsapAddress */
+         case 2:
+            stat = asn1PE_H245Q2931Address_address_nsapAddress (pctxt, pvalue->u.nsapAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address_subaddress                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Q2931Address                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.subaddressPresent);
+
+   /* encode address */
+
+   stat = asn1PE_H245Q2931Address_address (pctxt, &pvalue->address);
+   if (stat != ASN_OK) return stat;
+
+   /* encode subaddress */
+
+   if (pvalue->m.subaddressPresent) {
+      stat = asn1PE_H245Q2931Address_subaddress (pctxt, &pvalue->subaddress);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1ViaGateway_gatewayAddress                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245Q2931Address (pctxt, ((H245Q2931Address*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability_aal1ViaGateway                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode gatewayAddress */
+
+   stat = asn1PE_H245VCCapability_aal1ViaGateway_gatewayAddress (pctxt, &pvalue->gatewayAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nullClockRecovery */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nullClockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   /* encode srtsClockRecovery */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->srtsClockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   /* encode adaptiveClockRecovery */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->adaptiveClockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nullErrorCorrection */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nullErrorCorrection);
+   if (stat != ASN_OK) return stat;
+
+   /* encode longInterleaver */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->longInterleaver);
+   if (stat != ASN_OK) return stat;
+
+   /* encode shortInterleaver */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->shortInterleaver);
+   if (stat != ASN_OK) return stat;
+
+   /* encode errorCorrectionOnly */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->errorCorrectionOnly);
+   if (stat != ASN_OK) return stat;
+
+   /* encode structuredDataTransfer */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->structuredDataTransfer);
+   if (stat != ASN_OK) return stat;
+
+   /* encode partiallyFilledCells */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partiallyFilledCells);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VCCapability                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.aal1ViaGatewayPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.aal1Present);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.aal5Present);
+
+   /* encode aal1 */
+
+   if (pvalue->m.aal1Present) {
+      stat = asn1PE_H245VCCapability_aal1 (pctxt, &pvalue->aal1);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode aal5 */
+
+   if (pvalue->m.aal5Present) {
+      stat = asn1PE_H245VCCapability_aal5 (pctxt, &pvalue->aal5);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode transportStream */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->transportStream);
+   if (stat != ASN_OK) return stat;
+
+   /* encode programStream */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->programStream);
+   if (stat != ASN_OK) return stat;
+
+   /* encode availableBitRates */
+
+   stat = asn1PE_H245VCCapability_availableBitRates (pctxt, &pvalue->availableBitRates);
+   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.aal1ViaGatewayPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.aal1ViaGatewayPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245VCCapability_aal1ViaGateway (&lctxt, &pvalue->aal1ViaGateway);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SetOfH245VCCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245VCCapability (pctxt, ((H245VCCapability*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H222Capability                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode numberOfVCs */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfVCs, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode vcCapability */
+
+   stat = asn1PE_H245_SetOfH245VCCapability (pctxt, &pvalue->vcCapability);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223Capability_h223MultiplexTableCapability_enhanced      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* 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;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->bitRate, 1U, 19200U);
+         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.mobileMultilinkFrameCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245H223Capability_mobileMultilinkFrameCapability (&lctxt, &pvalue->mobileMultilinkFrameCapability);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V75Capability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode audioHeader */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioHeader);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76Capability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode suspendResumeCapabilitywAddress */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->suspendResumeCapabilitywAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode suspendResumeCapabilitywoAddress */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->suspendResumeCapabilitywoAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->rejCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sREJCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->sREJCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mREJCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mREJCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode crc8bitCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->crc8bitCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode crc16bitCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->crc16bitCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode crc32bitCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->crc32bitCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode uihCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->uihCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode numOfDLCS */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numOfDLCS, 2U, 8191U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode twoOctetAddressFieldCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->twoOctetAddressFieldCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode loopBackTestCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->loopBackTestCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode n401Capability */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->n401Capability, 1U, 4095U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maxWindowSizeCapability */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxWindowSizeCapability, 1U, 127U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode v75Capability */
+
+   stat = asn1PE_H245V75Capability (pctxt, &pvalue->v75Capability);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T84Profile_t84Restricted                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode qcif */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->qcif);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cif */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->cif);
+   if (stat != ASN_OK) return stat;
+
+   /* encode ccir601Seq */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->ccir601Seq);
+   if (stat != ASN_OK) return stat;
+
+   /* encode ccir601Prog */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->ccir601Prog);
+   if (stat != ASN_OK) return stat;
+
+   /* encode hdtvSeq */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->hdtvSeq);
+   if (stat != ASN_OK) return stat;
+
+   /* encode hdtvProg */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->hdtvProg);
+   if (stat != ASN_OK) return stat;
+
+   /* encode g3FacsMH200x100 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->g3FacsMH200x100);
+   if (stat != ASN_OK) return stat;
+
+   /* encode g3FacsMH200x200 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->g3FacsMH200x200);
+   if (stat != ASN_OK) return stat;
+
+   /* encode g4FacsMMR200x100 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->g4FacsMMR200x100);
+   if (stat != ASN_OK) return stat;
+
+   /* encode g4FacsMMR200x200 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->g4FacsMMR200x200);
+   if (stat != ASN_OK) return stat;
+
+   /* encode jbig200x200Seq */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->jbig200x200Seq);
+   if (stat != ASN_OK) return stat;
+
+   /* encode jbig200x200Prog */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->jbig200x200Prog);
+   if (stat != ASN_OK) return stat;
+
+   /* encode jbig300x300Seq */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->jbig300x300Seq);
+   if (stat != ASN_OK) return stat;
+
+   /* encode jbig300x300Prog */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->jbig300x300Prog);
+   if (stat != ASN_OK) return stat;
+
+   /* encode digPhotoLow */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoLow);
+   if (stat != ASN_OK) return stat;
+
+   /* encode digPhotoMedSeq */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoMedSeq);
+   if (stat != ASN_OK) return stat;
+
+   /* encode digPhotoMedProg */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoMedProg);
+   if (stat != ASN_OK) return stat;
+
+   /* encode digPhotoHighSeq */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoHighSeq);
+   if (stat != ASN_OK) return stat;
+
+   /* encode digPhotoHighProg */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoHighProg);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  T84Profile                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245T84Profile (OOCTXT* pctxt, H245T84Profile* 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)
+   {
+      /* t84Unrestricted */
+      case 1:
+         /* NULL */
+         break;
+
+      /* t84Restricted */
+      case 2:
+         stat = asn1PE_H245T84Profile_t84Restricted (pctxt, pvalue->u.t84Restricted);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_t84                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataApplicationCapability_application_t84 (OOCTXT* pctxt, H245DataApplicationCapability_application_t84* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode t84Protocol */
+
+   stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t84Protocol);
+   if (stat != ASN_OK) return stat;
+
+   /* encode t84Profile */
+
+   stat = asn1PE_H245T84Profile (pctxt, &pvalue->t84Profile);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_nlpid               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataApplicationCapability_application_nlpid (OOCTXT* pctxt, H245DataApplicationCapability_application_nlpid* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode nlpidProtocol */
+
+   stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->nlpidProtocol);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nlpidData */
+
+   stat = encodeOctetString (pctxt, pvalue->nlpidData.numocts, pvalue->nlpidData.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application_t38fax              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataApplicationCapability_application_t38fax (OOCTXT* pctxt, H245DataApplicationCapability_application_t38fax* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode t38FaxProtocol */
+
+   stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol);
+   if (stat != ASN_OK) return stat;
+
+   /* encode t38FaxProfile */
+
+   stat = asn1PE_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityIdentifier_uuid                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CapabilityIdentifier_uuid (OOCTXT* pctxt, H245CapabilityIdentifier_uuid* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CapabilityIdentifier (OOCTXT* pctxt, H245CapabilityIdentifier* pvalue)
+{
+   static Asn1SizeCnst domainBased_lsize1 = { 0, 1, 64, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* standard */
+         case 1:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.standard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h221NonStandard */
+         case 2:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.h221NonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* uuid */
+         case 3:
+            stat = asn1PE_H245CapabilityIdentifier_uuid (pctxt, pvalue->u.uuid);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* domainBased */
+         case 4:
+            addSizeConstraint (pctxt, &domainBased_lsize1);
+
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.domainBased, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterIdentifier_uuid                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ParameterIdentifier_uuid (OOCTXT* pctxt, H245ParameterIdentifier_uuid* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterIdentifier                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ParameterIdentifier (OOCTXT* pctxt, H245ParameterIdentifier* pvalue)
+{
+   static Asn1SizeCnst domainBased_lsize1 = { 0, 1, 64, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* standard */
+         case 1:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.standard, 0U, 127U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* h221NonStandard */
+         case 2:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.h221NonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* uuid */
+         case 3:
+            stat = asn1PE_H245ParameterIdentifier_uuid (pctxt, pvalue->u.uuid);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* domainBased */
+         case 4:
+            addSizeConstraint (pctxt, &domainBased_lsize1);
+
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.domainBased, 0, 8, 7, 7);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ParameterValue                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ParameterValue (OOCTXT* pctxt, H245ParameterValue* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 8);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* logical */
+         case 1:
+            /* NULL */
+            break;
+
+         /* booleanArray */
+         case 2:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.booleanArray, 0U, 255U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* unsignedMin */
+         case 3:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.unsignedMin, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* unsignedMax */
+         case 4:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.unsignedMax, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* unsigned32Min */
+         case 5:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.unsigned32Min, 0U, ASN1UINT_MAX);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* unsigned32Max */
+         case 6:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.unsigned32Max, 0U, ASN1UINT_MAX);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* octetString */
+         case 7:
+            stat = encodeOctetString (pctxt, pvalue->u.octetString->numocts, pvalue->u.octetString->data);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* genericParameter */
+         case 8:
+            stat = asn1PE_H245_SeqOfH245GenericParameter (pctxt, (H245_SeqOfH245GenericParameter*)pvalue->u.genericParameter);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245ParameterIdentifier                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245ParameterIdentifier (OOCTXT* pctxt, H245_SeqOfH245ParameterIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245ParameterIdentifier (pctxt, ((H245ParameterIdentifier*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericParameter                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245GenericParameter (OOCTXT* pctxt, H245GenericParameter* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.supersedesPresent);
+
+   /* encode parameterIdentifier */
+
+   stat = asn1PE_H245ParameterIdentifier (pctxt, &pvalue->parameterIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode parameterValue */
+
+   stat = asn1PE_H245ParameterValue (pctxt, &pvalue->parameterValue);
+   if (stat != ASN_OK) return stat;
+
+   /* encode supersedes */
+
+   if (pvalue->m.supersedesPresent) {
+      stat = asn1PE_H245_SeqOfH245ParameterIdentifier (pctxt, &pvalue->supersedes);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245GenericParameter                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245GenericParameter (OOCTXT* pctxt, H245_SeqOfH245GenericParameter* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245GenericParameter (pctxt, ((H245GenericParameter*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GenericCapability                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245GenericCapability (OOCTXT* pctxt, H245GenericCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.maxBitRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.collapsingPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonCollapsingPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonCollapsingRawPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportPresent);
+
+   /* encode capabilityIdentifier */
+
+   stat = asn1PE_H245CapabilityIdentifier (pctxt, &pvalue->capabilityIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maxBitRate */
+
+   if (pvalue->m.maxBitRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode collapsing */
+
+   if (pvalue->m.collapsingPresent) {
+      stat = asn1PE_H245_SeqOfH245GenericParameter (pctxt, &pvalue->collapsing);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode nonCollapsing */
+
+   if (pvalue->m.nonCollapsingPresent) {
+      stat = asn1PE_H245_SeqOfH245GenericParameter (pctxt, &pvalue->nonCollapsing);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode nonCollapsingRaw */
+
+   if (pvalue->m.nonCollapsingRawPresent) {
+      stat = encodeOctetString (pctxt, pvalue->nonCollapsingRaw.numocts, pvalue->nonCollapsingRaw.data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode transport */
+
+   if (pvalue->m.transportPresent) {
+      stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->transport);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability_application                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataApplicationCapability_application (OOCTXT* pctxt, H245DataApplicationCapability_application* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 10);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* t120 */
+         case 2:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t120);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* dsm_cc */
+         case 3:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.dsm_cc);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* userData */
+         case 4:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.userData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* t84 */
+         case 5:
+            stat = asn1PE_H245DataApplicationCapability_application_t84 (pctxt, pvalue->u.t84);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* t434 */
+         case 6:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t434);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h224 */
+         case 7:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.h224);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nlpid */
+         case 8:
+            stat = asn1PE_H245DataApplicationCapability_application_nlpid (pctxt, pvalue->u.nlpid);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* dsvdControl */
+         case 9:
+            /* NULL */
+            break;
+
+         /* h222DataPartitioning */
+         case 10:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.h222DataPartitioning);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* t30fax */
+         case 11:
+            stat = asn1PE_H245DataProtocolCapability (&lctxt, pvalue->u.t30fax);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* t140 */
+         case 12:
+            stat = asn1PE_H245DataProtocolCapability (&lctxt, pvalue->u.t140);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* t38fax */
+         case 13:
+            stat = asn1PE_H245DataApplicationCapability_application_t38fax (&lctxt, pvalue->u.t38fax);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericDataCapability */
+         case 14:
+            stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericDataCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataApplicationCapability                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataApplicationCapability (OOCTXT* pctxt, H245DataApplicationCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode application */
+
+   stat = asn1PE_H245DataApplicationCapability_application (pctxt, &pvalue->application);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maxBitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245DataApplicationCapability                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245DataApplicationCapability (OOCTXT* pctxt, H245_SeqOfH245DataApplicationCapability* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245DataApplicationCapability (pctxt, ((H245DataApplicationCapability*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaDistributionCapability                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MediaDistributionCapability (OOCTXT* pctxt, H245MediaDistributionCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.centralizedDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.distributedDataPresent);
+
+   /* encode centralizedControl */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->centralizedControl);
+   if (stat != ASN_OK) return stat;
+
+   /* encode distributedControl */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->distributedControl);
+   if (stat != ASN_OK) return stat;
+
+   /* encode centralizedAudio */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->centralizedAudio);
+   if (stat != ASN_OK) return stat;
+
+   /* encode distributedAudio */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->distributedAudio);
+   if (stat != ASN_OK) return stat;
+
+   /* encode centralizedVideo */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->centralizedVideo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode distributedVideo */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->distributedVideo);
+   if (stat != ASN_OK) return stat;
+
+   /* encode centralizedData */
+
+   if (pvalue->m.centralizedDataPresent) {
+      stat = asn1PE_H245_SeqOfH245DataApplicationCapability (pctxt, &pvalue->centralizedData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode distributedData */
+
+   if (pvalue->m.distributedDataPresent) {
+      stat = asn1PE_H245_SeqOfH245DataApplicationCapability (pctxt, &pvalue->distributedData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MediaDistributionCapability                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245MediaDistributionCapability (OOCTXT* pctxt, H245_SeqOfH245MediaDistributionCapability* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245MediaDistributionCapability (pctxt, ((H245MediaDistributionCapability*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultipointCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultipointCapability (OOCTXT* pctxt, H245MultipointCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode multicastCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multicastCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiUniCastConference */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multiUniCastConference);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mediaDistributionCapability */
+
+   stat = asn1PE_H245_SeqOfH245MediaDistributionCapability (pctxt, &pvalue->mediaDistributionCapability);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability_mcCapability                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H2250Capability_mcCapability (OOCTXT* pctxt, H245H2250Capability_mcCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode centralizedConferenceMC */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->centralizedConferenceMC);
+   if (stat != ASN_OK) return stat;
+
+   /* encode decentralizedConferenceMC */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->decentralizedConferenceMC);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPPayloadType_payloadDescriptor                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RTPPayloadType_payloadDescriptor (OOCTXT* pctxt, H245RTPPayloadType_payloadDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandardIdentifier */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandardIdentifier);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* rfc_number */
+         case 2:
+            if ( (pvalue->u.rfc_number >= 1 && pvalue->u.rfc_number <= 32768) ) {
+               extbit = 0;
+            }
+            else extbit = 1;
+
+            /* extension bit */
+
+            encodeBit (pctxt, extbit);
+
+            if (extbit) {
+               stat = encodeUnconsInteger (pctxt, pvalue->u.rfc_number);
+               if (stat != ASN_OK) return stat;
+            }
+            else {
+               stat = encodeConsInteger (pctxt, pvalue->u.rfc_number, 1, 32768);
+               if (stat != ASN_OK) return stat;
+            }
+            break;
+
+         /* oid */
+         case 3:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.oid);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPPayloadType                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RTPPayloadType (OOCTXT* pctxt, H245RTPPayloadType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.payloadTypePresent);
+
+   /* encode payloadDescriptor */
+
+   stat = asn1PE_H245RTPPayloadType_payloadDescriptor (pctxt, &pvalue->payloadDescriptor);
+   if (stat != ASN_OK) return stat;
+
+   /* encode payloadType */
+
+   if (pvalue->m.payloadTypePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->payloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaPacketizationCapability_rtpPayloadType               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MediaPacketizationCapability_rtpPayloadType (OOCTXT* pctxt, H245MediaPacketizationCapability_rtpPayloadType* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245RTPPayloadType (pctxt, ((H245RTPPayloadType*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaPacketizationCapability                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MediaPacketizationCapability (OOCTXT* pctxt, H245MediaPacketizationCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.rtpPayloadTypePresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode h261aVideoPacketization */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h261aVideoPacketization);
+   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.rtpPayloadTypePresent);
+      /* encode extension elements */
+
+      if (pvalue->m.rtpPayloadTypePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245MediaPacketizationCapability_rtpPayloadType (&lctxt, &pvalue->rtpPayloadType);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  QOSMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245QOSMode (OOCTXT* pctxt, H245QOSMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* guaranteedQOS */
+         case 1:
+            /* NULL */
+            break;
+
+         /* controlledLoad */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RSVPParameters                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RSVPParameters (OOCTXT* pctxt, H245RSVPParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.qosModePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokenRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.bucketSizePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.peakRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.minPolicedPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.maxPktSizePresent);
+
+   /* encode qosMode */
+
+   if (pvalue->m.qosModePresent) {
+      stat = asn1PE_H245QOSMode (pctxt, &pvalue->qosMode);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode tokenRate */
+
+   if (pvalue->m.tokenRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->tokenRate, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode bucketSize */
+
+   if (pvalue->m.bucketSizePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->bucketSize, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode peakRate */
+
+   if (pvalue->m.peakRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->peakRate, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode minPoliced */
+
+   if (pvalue->m.minPolicedPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->minPoliced, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode maxPktSize */
+
+   if (pvalue->m.maxPktSizePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->maxPktSize, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ATMParameters                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ATMParameters (OOCTXT* pctxt, H245ATMParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode maxNTUSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxNTUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode atmUBR */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmUBR);
+   if (stat != ASN_OK) return stat;
+
+   /* encode atmrtVBR */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmrtVBR);
+   if (stat != ASN_OK) return stat;
+
+   /* encode atmnrtVBR */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmnrtVBR);
+   if (stat != ASN_OK) return stat;
+
+   /* encode atmABR */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmABR);
+   if (stat != ASN_OK) return stat;
+
+   /* encode atmCBR */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmCBR);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  QOSCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245QOSCapability (OOCTXT* pctxt, H245QOSCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.rsvpParametersPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.atmParametersPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode rsvpParameters */
+
+   if (pvalue->m.rsvpParametersPresent) {
+      stat = asn1PE_H245RSVPParameters (pctxt, &pvalue->rsvpParameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode atmParameters */
+
+   if (pvalue->m.atmParametersPresent) {
+      stat = asn1PE_H245ATMParameters (pctxt, &pvalue->atmParameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability_qOSCapabilities                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TransportCapability_qOSCapabilities (OOCTXT* pctxt, H245TransportCapability_qOSCapabilities* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245QOSCapability (pctxt, ((H245QOSCapability*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaTransportType_atm_AAL5_compressed                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MediaTransportType_atm_AAL5_compressed (OOCTXT* pctxt, H245MediaTransportType_atm_AAL5_compressed* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode variable_delta */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->variable_delta);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaTransportType                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MediaTransportType (OOCTXT* pctxt, H245MediaTransportType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* ip_UDP */
+         case 1:
+            /* NULL */
+            break;
+
+         /* ip_TCP */
+         case 2:
+            /* NULL */
+            break;
+
+         /* atm_AAL5_UNIDIR */
+         case 3:
+            /* NULL */
+            break;
+
+         /* atm_AAL5_BIDIR */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* atm_AAL5_compressed */
+         case 5:
+            stat = asn1PE_H245MediaTransportType_atm_AAL5_compressed (&lctxt, pvalue->u.atm_AAL5_compressed);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaChannelCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MediaChannelCapability (OOCTXT* pctxt, H245MediaChannelCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaTransportPresent);
+
+   /* encode mediaTransport */
+
+   if (pvalue->m.mediaTransportPresent) {
+      stat = asn1PE_H245MediaTransportType (pctxt, &pvalue->mediaTransport);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability_mediaChannelCapabilities              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TransportCapability_mediaChannelCapabilities (OOCTXT* pctxt, H245TransportCapability_mediaChannelCapabilities* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245MediaChannelCapability (pctxt, ((H245MediaChannelCapability*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TransportCapability (OOCTXT* pctxt, H245TransportCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.qOSCapabilitiesPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaChannelCapabilitiesPresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode qOSCapabilities */
+
+   if (pvalue->m.qOSCapabilitiesPresent) {
+      stat = asn1PE_H245TransportCapability_qOSCapabilities (pctxt, &pvalue->qOSCapabilities);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mediaChannelCapabilities */
+
+   if (pvalue->m.mediaChannelCapabilitiesPresent) {
+      stat = asn1PE_H245TransportCapability_mediaChannelCapabilities (pctxt, &pvalue->mediaChannelCapabilities);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyFrameMapping_frameSequence          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyFrameMapping_frameSequence (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping_frameSequence* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 0U, 255U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyFrameMapping                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyFrameMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode threadNumber */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->threadNumber, 0U, 15U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode frameSequence */
+
+   stat = asn1PE_H245RTPH263VideoRedundancyFrameMapping_frameSequence (pctxt, &pvalue->frameSequence);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_frameToThreadMapping_cust  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245RTPH263VideoRedundancyFrameMapping (pctxt, ((H245RTPH263VideoRedundancyFrameMapping*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_frameToThreadMapping       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* roundrobin */
+         case 1:
+            /* NULL */
+            break;
+
+         /* custom */
+         case 2:
+            stat = asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (pctxt, pvalue->u.custom);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding_containedThreads           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_containedThreads (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_containedThreads* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 0U, 15U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RTPH263VideoRedundancyEncoding                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.containedThreadsPresent);
+
+   /* encode numberOfThreads */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfThreads, 1U, 16U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode framesBetweenSyncPoints */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->framesBetweenSyncPoints, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode frameToThreadMapping */
+
+   stat = asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (pctxt, &pvalue->frameToThreadMapping);
+   if (stat != ASN_OK) return stat;
+
+   /* encode containedThreads */
+
+   if (pvalue->m.containedThreadsPresent) {
+      stat = asn1PE_H245RTPH263VideoRedundancyEncoding_containedThreads (pctxt, &pvalue->containedThreads);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMethod                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingMethod (OOCTXT* pctxt, H245RedundancyEncodingMethod* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* rtpAudioRedundancyEncoding */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* rtpH263VideoRedundancyEncoding */
+         case 3:
+            stat = asn1PE_H245RTPH263VideoRedundancyEncoding (&lctxt, pvalue->u.rtpH263VideoRedundancyEncoding);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityTableEntryNumber                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CapabilityTableEntryNumber (OOCTXT* pctxt, H245CapabilityTableEntryNumber value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingCapability_secondaryEncoding            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingCapability_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingCapability_secondaryEncoding* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingCapability                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingCapability (OOCTXT* pctxt, H245RedundancyEncodingCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.secondaryEncodingPresent);
+
+   /* encode redundancyEncodingMethod */
+
+   stat = asn1PE_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod);
+   if (stat != ASN_OK) return stat;
+
+   /* encode primaryEncoding */
+
+   stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->primaryEncoding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode secondaryEncoding */
+
+   if (pvalue->m.secondaryEncodingPresent) {
+      stat = asn1PE_H245RedundancyEncodingCapability_secondaryEncoding (pctxt, &pvalue->secondaryEncoding);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability_redundancyEncodingCapability              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H2250Capability_redundancyEncodingCapability (OOCTXT* pctxt, H245H2250Capability_redundancyEncodingCapability* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245RedundancyEncodingCapability (pctxt, ((H245RedundancyEncodingCapability*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250Capability                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H2250Capability (OOCTXT* pctxt, H245H2250Capability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.transportCapabilityPresent ||
+   pvalue->m.redundancyEncodingCapabilityPresent ||
+   pvalue->m.logicalChannelSwitchingCapabilityPresent ||
+   pvalue->m.t120DynamicPortCapabilityPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode maximumAudioDelayJitter */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maximumAudioDelayJitter, 0U, 1023U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode receiveMultipointCapability */
+
+   stat = asn1PE_H245MultipointCapability (pctxt, &pvalue->receiveMultipointCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode transmitMultipointCapability */
+
+   stat = asn1PE_H245MultipointCapability (pctxt, &pvalue->transmitMultipointCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode receiveAndTransmitMultipointCapability */
+
+   stat = asn1PE_H245MultipointCapability (pctxt, &pvalue->receiveAndTransmitMultipointCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mcCapability */
+
+   stat = asn1PE_H245H2250Capability_mcCapability (pctxt, &pvalue->mcCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rtcpVideoControlCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->rtcpVideoControlCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mediaPacketizationCapability */
+
+   stat = asn1PE_H245MediaPacketizationCapability (pctxt, &pvalue->mediaPacketizationCapability);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.redundancyEncodingCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.logicalChannelSwitchingCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.t120DynamicPortCapabilityPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.transportCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245TransportCapability (&lctxt, &pvalue->transportCapability);
+         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.redundancyEncodingCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245H2250Capability_redundancyEncodingCapability (&lctxt, &pvalue->redundancyEncodingCapability);
+         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.logicalChannelSwitchingCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->logicalChannelSwitchingCapability);
+         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.t120DynamicPortCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->t120DynamicPortCapability);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexCapability (OOCTXT* pctxt, H245MultiplexCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h222Capability */
+         case 2:
+            stat = asn1PE_H245H222Capability (pctxt, pvalue->u.h222Capability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h223Capability */
+         case 3:
+            stat = asn1PE_H245H223Capability (pctxt, pvalue->u.h223Capability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* v76Capability */
+         case 4:
+            stat = asn1PE_H245V76Capability (pctxt, pvalue->u.v76Capability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* h2250Capability */
+         case 5:
+            stat = asn1PE_H245H2250Capability (&lctxt, pvalue->u.h2250Capability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericMultiplexCapability */
+         case 6:
+            stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericMultiplexCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H261VideoCapability (OOCTXT* pctxt, H245H261VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.videoBadMBsCapPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifMPIPresent);
+
+   /* encode qcifMPI */
+
+   if (pvalue->m.qcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->qcifMPI, 1U, 4U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cifMPI */
+
+   if (pvalue->m.cifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cifMPI, 1U, 4U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode temporalSpatialTradeOffCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->temporalSpatialTradeOffCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maxBitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 1U, 19200U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode stillImageTransmission */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->stillImageTransmission);
+   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.videoBadMBsCapPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.videoBadMBsCapPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoBadMBsCap);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H262VideoCapability (OOCTXT* pctxt, H245H262VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.videoBadMBsCapPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBitRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.vbvBufferSizePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.samplesPerLinePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.linesPerFramePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.framesPerSecondPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.luminanceSampleRatePresent);
+
+   /* encode profileAndLevel_SPatML */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_SPatML);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_MPatLL */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_MPatLL);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_MPatML */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_MPatML);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_MPatH_14 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_MPatH_14);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_MPatHL */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_MPatHL);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_SNRatLL */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_SNRatLL);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_SNRatML */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_SNRatML);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_SpatialatH_14 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_SpatialatH_14);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_HPatML */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_HPatML);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_HPatH_14 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_HPatH_14);
+   if (stat != ASN_OK) return stat;
+
+   /* encode profileAndLevel_HPatHL */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_HPatHL);
+   if (stat != ASN_OK) return stat;
+
+   /* encode videoBitRate */
+
+   if (pvalue->m.videoBitRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->videoBitRate, 0U, 1073741823U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode vbvBufferSize */
+
+   if (pvalue->m.vbvBufferSizePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->vbvBufferSize, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode samplesPerLine */
+
+   if (pvalue->m.samplesPerLinePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->samplesPerLine, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode linesPerFrame */
+
+   if (pvalue->m.linesPerFramePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->linesPerFrame, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode framesPerSecond */
+
+   if (pvalue->m.framesPerSecondPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->framesPerSecond, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode luminanceSampleRate */
+
+   if (pvalue->m.luminanceSampleRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX);
+      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.videoBadMBsCapPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.videoBadMBsCapPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoBadMBsCap);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransparencyParameters                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TransparencyParameters (OOCTXT* pctxt, H245TransparencyParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode presentationOrder */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->presentationOrder, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode offset_x */
+
+   stat = encodeConsInteger (pctxt, pvalue->offset_x, -262144, 262143);
+   if (stat != ASN_OK) return stat;
+
+   /* encode offset_y */
+
+   stat = encodeConsInteger (pctxt, pvalue->offset_y, -262144, 262143);
+   if (stat != ASN_OK) return stat;
+
+   /* encode scale_x */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->scale_x, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode scale_y */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->scale_y, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_additionalPictureMemory               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RefPictureSelection_additionalPictureMemory (OOCTXT* pctxt, H245RefPictureSelection_additionalPictureMemory* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sqcifAdditionalPictureMemoryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifAdditionalPictureMemoryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifAdditionalPictureMemoryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif4AdditionalPictureMemoryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif16AdditionalPictureMemoryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.bigCpfAdditionalPictureMemoryPresent);
+
+   /* encode sqcifAdditionalPictureMemory */
+
+   if (pvalue->m.sqcifAdditionalPictureMemoryPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->sqcifAdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode qcifAdditionalPictureMemory */
+
+   if (pvalue->m.qcifAdditionalPictureMemoryPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->qcifAdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cifAdditionalPictureMemory */
+
+   if (pvalue->m.cifAdditionalPictureMemoryPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cifAdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cif4AdditionalPictureMemory */
+
+   if (pvalue->m.cif4AdditionalPictureMemoryPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cif4AdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cif16AdditionalPictureMemory */
+
+   if (pvalue->m.cif16AdditionalPictureMemoryPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cif16AdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode bigCpfAdditionalPictureMemory */
+
+   if (pvalue->m.bigCpfAdditionalPictureMemoryPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->bigCpfAdditionalPictureMemory, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_videoBackChannelSend                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RefPictureSelection_videoBackChannelSend (OOCTXT* pctxt, H245RefPictureSelection_videoBackChannelSend* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* none */
+         case 1:
+            /* NULL */
+            break;
+
+         /* ackMessageOnly */
+         case 2:
+            /* NULL */
+            break;
+
+         /* nackMessageOnly */
+         case 3:
+            /* NULL */
+            break;
+
+         /* ackOrNackMessageOnly */
+         case 4:
+            /* NULL */
+            break;
+
+         /* ackAndNackMessage */
+         case 5:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_enhancedReferencePicSelect_subPictur  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode mpuHorizMBs */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->mpuHorizMBs, 1U, 128U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mpuVertMBs */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->mpuVertMBs, 1U, 72U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mpuTotalNumber */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->mpuTotalNumber, 1U, 65536U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection_enhancedReferencePicSelect            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RefPictureSelection_enhancedReferencePicSelect (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.subPictureRemovalParametersPresent);
+
+   /* encode subPictureRemovalParameters */
+
+   if (pvalue->m.subPictureRemovalParametersPresent) {
+      stat = asn1PE_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (pctxt, &pvalue->subPictureRemovalParameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RefPictureSelection                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RefPictureSelection (OOCTXT* pctxt, H245RefPictureSelection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.enhancedReferencePicSelectPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.additionalPictureMemoryPresent);
+
+   /* encode additionalPictureMemory */
+
+   if (pvalue->m.additionalPictureMemoryPresent) {
+      stat = asn1PE_H245RefPictureSelection_additionalPictureMemory (pctxt, &pvalue->additionalPictureMemory);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode videoMux */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoMux);
+   if (stat != ASN_OK) return stat;
+
+   /* encode videoBackChannelSend */
+
+   stat = asn1PE_H245RefPictureSelection_videoBackChannelSend (pctxt, &pvalue->videoBackChannelSend);
+   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.enhancedReferencePicSelectPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.enhancedReferencePicSelectPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245RefPictureSelection_enhancedReferencePicSelect (&lctxt, &pvalue->enhancedReferencePicSelect);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureClockFrequency                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureClockFrequency (OOCTXT* pctxt, H245CustomPictureClockFrequency* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sqcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif4MPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif16MPIPresent);
+
+   /* encode clockConversionCode */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->clockConversionCode, 1000U, 1001U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode clockDivisor */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->clockDivisor, 1U, 127U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sqcifMPI */
+
+   if (pvalue->m.sqcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->sqcifMPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode qcifMPI */
+
+   if (pvalue->m.qcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->qcifMPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cifMPI */
+
+   if (pvalue->m.cifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cifMPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cif4MPI */
+
+   if (pvalue->m.cif4MPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cif4MPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cif16MPI */
+
+   if (pvalue->m.cif16MPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cif16MPI, 1U, 2048U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_customPictureClockFrequency                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263Options_customPictureClockFrequency (OOCTXT* pctxt, H245H263Options_customPictureClockFrequency* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245CustomPictureClockFrequency (pctxt, ((H245CustomPictureClockFrequency*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI_customPCF_element                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureFormat_mPI_customPCF_element (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode clockConversionCode */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->clockConversionCode, 1000U, 1001U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode clockDivisor */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->clockDivisor, 1U, 127U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode customMPI */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->customMPI, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI_customPCF                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureFormat_mPI_customPCF (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245CustomPictureFormat_mPI_customPCF_element (pctxt, ((H245CustomPictureFormat_mPI_customPCF_element*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_mPI                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureFormat_mPI (OOCTXT* pctxt, H245CustomPictureFormat_mPI* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.standardMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.customPCFPresent);
+
+   /* encode standardMPI */
+
+   if (pvalue->m.standardMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->standardMPI, 1U, 31U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode customPCF */
+
+   if (pvalue->m.customPCFPresent) {
+      stat = asn1PE_H245CustomPictureFormat_mPI_customPCF (pctxt, &pvalue->customPCF);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_pixelAspectCo  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 1U, 14U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_extendedPAR_e  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode width */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->width, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode height */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->height, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation_extendedPAR    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (pctxt, ((H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat_pixelAspectInformation                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* anyPixelAspectRatio */
+         case 1:
+            stat = encodeBit (pctxt, (ASN1BOOL)pvalue->u.anyPixelAspectRatio);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* pixelAspectCode */
+         case 2:
+            stat = asn1PE_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (pctxt, pvalue->u.pixelAspectCode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* extendedPAR */
+         case 3:
+            stat = asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (pctxt, pvalue->u.extendedPAR);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CustomPictureFormat                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CustomPictureFormat (OOCTXT* pctxt, H245CustomPictureFormat* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode maxCustomPictureWidth */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxCustomPictureWidth, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maxCustomPictureHeight */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxCustomPictureHeight, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode minCustomPictureWidth */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->minCustomPictureWidth, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode minCustomPictureHeight */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->minCustomPictureHeight, 1U, 2048U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mPI */
+
+   stat = asn1PE_H245CustomPictureFormat_mPI (pctxt, &pvalue->mPI);
+   if (stat != ASN_OK) return stat;
+
+   /* encode pixelAspectInformation */
+
+   stat = asn1PE_H245CustomPictureFormat_pixelAspectInformation (pctxt, &pvalue->pixelAspectInformation);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_customPictureFormat                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263Options_customPictureFormat (OOCTXT* pctxt, H245H263Options_customPictureFormat* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245CustomPictureFormat (pctxt, ((H245CustomPictureFormat*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Version3Options                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263Version3Options (OOCTXT* pctxt, H245H263Version3Options* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode dataPartitionedSlices */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataPartitionedSlices);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fixedPointIDCT0 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fixedPointIDCT0);
+   if (stat != ASN_OK) return stat;
+
+   /* encode interlacedFields */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->interlacedFields);
+   if (stat != ASN_OK) return stat;
+
+   /* encode currentPictureHeaderRepetition */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->currentPictureHeaderRepetition);
+   if (stat != ASN_OK) return stat;
+
+   /* encode previousPictureHeaderRepetition */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->previousPictureHeaderRepetition);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nextPictureHeaderRepetition */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nextPictureHeaderRepetition);
+   if (stat != ASN_OK) return stat;
+
+   /* encode pictureNumber */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->pictureNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode spareReferencePictures */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->spareReferencePictures);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263ModeComboFlags                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263ModeComboFlags (OOCTXT* pctxt, H245H263ModeComboFlags* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.enhancedReferencePicSelectPresent ||
+   pvalue->m.h263Version3OptionsPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode unrestrictedVector */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unrestrictedVector);
+   if (stat != ASN_OK) return stat;
+
+   /* encode arithmeticCoding */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->arithmeticCoding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode advancedPrediction */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedPrediction);
+   if (stat != ASN_OK) return stat;
+
+   /* encode pbFrames */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->pbFrames);
+   if (stat != ASN_OK) return stat;
+
+   /* encode advancedIntraCodingMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedIntraCodingMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode deblockingFilterMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->deblockingFilterMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode unlimitedMotionVectors */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unlimitedMotionVectors);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slicesInOrder_NonRect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesInOrder_NonRect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slicesInOrder_Rect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesInOrder_Rect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slicesNoOrder_NonRect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesNoOrder_NonRect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slicesNoOrder_Rect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesNoOrder_Rect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode improvedPBFramesMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->improvedPBFramesMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode referencePicSelect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->referencePicSelect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dynamicPictureResizingByFour */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicPictureResizingByFour);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dynamicPictureResizingSixteenthPel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicPictureResizingSixteenthPel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dynamicWarpingHalfPel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicWarpingHalfPel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dynamicWarpingSixteenthPel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicWarpingSixteenthPel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode reducedResolutionUpdate */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->reducedResolutionUpdate);
+   if (stat != ASN_OK) return stat;
+
+   /* encode independentSegmentDecoding */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->independentSegmentDecoding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alternateInterVLCMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alternateInterVLCMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode modifiedQuantizationMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->modifiedQuantizationMode);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.enhancedReferencePicSelectPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263Version3OptionsPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.enhancedReferencePicSelectPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->enhancedReferencePicSelect);
+         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.h263Version3OptionsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245H263Version3Options (&lctxt, &pvalue->h263Version3Options);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoModeCombos_h263VideoCoupledModes                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263VideoModeCombos_h263VideoCoupledModes (OOCTXT* pctxt, H245H263VideoModeCombos_h263VideoCoupledModes* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245H263ModeComboFlags (pctxt, ((H245H263ModeComboFlags*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoModeCombos                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263VideoModeCombos (OOCTXT* pctxt, H245H263VideoModeCombos* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode h263VideoUncoupledModes */
+
+   stat = asn1PE_H245H263ModeComboFlags (pctxt, &pvalue->h263VideoUncoupledModes);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h263VideoCoupledModes */
+
+   stat = asn1PE_H245H263VideoModeCombos_h263VideoCoupledModes (pctxt, &pvalue->h263VideoCoupledModes);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options_modeCombos                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263Options_modeCombos (OOCTXT* pctxt, H245H263Options_modeCombos* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245H263VideoModeCombos (pctxt, ((H245H263VideoModeCombos*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263Options                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263Options (OOCTXT* pctxt, H245H263Options* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.videoBadMBsCapPresent ||
+   pvalue->m.h263Version3OptionsPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.transparencyParametersPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.refPictureSelectionPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.customPictureClockFrequencyPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.customPictureFormatPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.modeCombosPresent);
+
+   /* encode advancedIntraCodingMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedIntraCodingMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode deblockingFilterMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->deblockingFilterMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode improvedPBFramesMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->improvedPBFramesMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode unlimitedMotionVectors */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unlimitedMotionVectors);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fullPictureFreeze */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fullPictureFreeze);
+   if (stat != ASN_OK) return stat;
+
+   /* encode partialPictureFreezeAndRelease */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partialPictureFreezeAndRelease);
+   if (stat != ASN_OK) return stat;
+
+   /* encode resizingPartPicFreezeAndRelease */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->resizingPartPicFreezeAndRelease);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fullPictureSnapshot */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fullPictureSnapshot);
+   if (stat != ASN_OK) return stat;
+
+   /* encode partialPictureSnapshot */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partialPictureSnapshot);
+   if (stat != ASN_OK) return stat;
+
+   /* encode videoSegmentTagging */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoSegmentTagging);
+   if (stat != ASN_OK) return stat;
+
+   /* encode progressiveRefinement */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->progressiveRefinement);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dynamicPictureResizingByFour */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicPictureResizingByFour);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dynamicPictureResizingSixteenthPel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicPictureResizingSixteenthPel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dynamicWarpingHalfPel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicWarpingHalfPel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dynamicWarpingSixteenthPel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicWarpingSixteenthPel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode independentSegmentDecoding */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->independentSegmentDecoding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slicesInOrder_NonRect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesInOrder_NonRect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slicesInOrder_Rect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesInOrder_Rect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slicesNoOrder_NonRect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesNoOrder_NonRect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slicesNoOrder_Rect */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesNoOrder_Rect);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alternateInterVLCMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alternateInterVLCMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode modifiedQuantizationMode */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->modifiedQuantizationMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode reducedResolutionUpdate */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->reducedResolutionUpdate);
+   if (stat != ASN_OK) return stat;
+
+   /* encode transparencyParameters */
+
+   if (pvalue->m.transparencyParametersPresent) {
+      stat = asn1PE_H245TransparencyParameters (pctxt, &pvalue->transparencyParameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode separateVideoBackChannel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->separateVideoBackChannel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode refPictureSelection */
+
+   if (pvalue->m.refPictureSelectionPresent) {
+      stat = asn1PE_H245RefPictureSelection (pctxt, &pvalue->refPictureSelection);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode customPictureClockFrequency */
+
+   if (pvalue->m.customPictureClockFrequencyPresent) {
+      stat = asn1PE_H245H263Options_customPictureClockFrequency (pctxt, &pvalue->customPictureClockFrequency);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode customPictureFormat */
+
+   if (pvalue->m.customPictureFormatPresent) {
+      stat = asn1PE_H245H263Options_customPictureFormat (pctxt, &pvalue->customPictureFormat);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode modeCombos */
+
+   if (pvalue->m.modeCombosPresent) {
+      stat = asn1PE_H245H263Options_modeCombos (pctxt, &pvalue->modeCombos);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBadMBsCapPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263Version3OptionsPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.videoBadMBsCapPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoBadMBsCap);
+         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.h263Version3OptionsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245H263Version3Options (&lctxt, &pvalue->h263Version3Options);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementOptions                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EnhancementOptions (OOCTXT* pctxt, H245EnhancementOptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sqcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif4MPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif16MPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowSqcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowQcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCif4MPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCif16MPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263OptionsPresent);
+
+   /* encode sqcifMPI */
+
+   if (pvalue->m.sqcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->sqcifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode qcifMPI */
+
+   if (pvalue->m.qcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->qcifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cifMPI */
+
+   if (pvalue->m.cifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cif4MPI */
+
+   if (pvalue->m.cif4MPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cif4MPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cif16MPI */
+
+   if (pvalue->m.cif16MPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cif16MPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode maxBitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 1U, 192400U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode unrestrictedVector */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unrestrictedVector);
+   if (stat != ASN_OK) return stat;
+
+   /* encode arithmeticCoding */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->arithmeticCoding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode temporalSpatialTradeOffCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->temporalSpatialTradeOffCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode slowSqcifMPI */
+
+   if (pvalue->m.slowSqcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->slowSqcifMPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode slowQcifMPI */
+
+   if (pvalue->m.slowQcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->slowQcifMPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode slowCifMPI */
+
+   if (pvalue->m.slowCifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->slowCifMPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode slowCif4MPI */
+
+   if (pvalue->m.slowCif4MPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->slowCif4MPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode slowCif16MPI */
+
+   if (pvalue->m.slowCif16MPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->slowCif16MPI, 1U, 3600U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode errorCompensation */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->errorCompensation);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h263Options */
+
+   if (pvalue->m.h263OptionsPresent) {
+      stat = asn1PE_H245H263Options (pctxt, &pvalue->h263Options);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_snrEnhancement                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EnhancementLayerInfo_snrEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_snrEnhancement* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245EnhancementOptions (pctxt, ((H245EnhancementOptions*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_spatialEnhancement                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EnhancementLayerInfo_spatialEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_spatialEnhancement* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245EnhancementOptions (pctxt, ((H245EnhancementOptions*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  BEnhancementParameters                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245BEnhancementParameters (OOCTXT* pctxt, H245BEnhancementParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode enhancementOptions */
+
+   stat = asn1PE_H245EnhancementOptions (pctxt, &pvalue->enhancementOptions);
+   if (stat != ASN_OK) return stat;
+
+   /* encode numberOfBPictures */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfBPictures, 1U, 64U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo_bPictureEnhancement                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EnhancementLayerInfo_bPictureEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_bPictureEnhancement* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245BEnhancementParameters (pctxt, ((H245BEnhancementParameters*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EnhancementLayerInfo                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EnhancementLayerInfo (OOCTXT* pctxt, H245EnhancementLayerInfo* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.snrEnhancementPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.spatialEnhancementPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.bPictureEnhancementPresent);
+
+   /* encode baseBitRateConstrained */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->baseBitRateConstrained);
+   if (stat != ASN_OK) return stat;
+
+   /* encode snrEnhancement */
+
+   if (pvalue->m.snrEnhancementPresent) {
+      stat = asn1PE_H245EnhancementLayerInfo_snrEnhancement (pctxt, &pvalue->snrEnhancement);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode spatialEnhancement */
+
+   if (pvalue->m.spatialEnhancementPresent) {
+      stat = asn1PE_H245EnhancementLayerInfo_spatialEnhancement (pctxt, &pvalue->spatialEnhancement);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode bPictureEnhancement */
+
+   if (pvalue->m.bPictureEnhancementPresent) {
+      stat = asn1PE_H245EnhancementLayerInfo_bPictureEnhancement (pctxt, &pvalue->bPictureEnhancement);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263VideoCapability (OOCTXT* pctxt, H245H263VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.slowSqcifMPIPresent ||
+   pvalue->m.slowQcifMPIPresent ||
+   pvalue->m.slowCifMPIPresent ||
+   pvalue->m.slowCif4MPIPresent ||
+   pvalue->m.slowCif16MPIPresent ||
+   pvalue->m.errorCompensationPresent ||
+   pvalue->m.enhancementLayerInfoPresent ||
+   pvalue->m.h263OptionsPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sqcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifMPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif4MPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif16MPIPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.hrd_BPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.bppMaxKbPresent);
+
+   /* encode sqcifMPI */
+
+   if (pvalue->m.sqcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->sqcifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode qcifMPI */
+
+   if (pvalue->m.qcifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->qcifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cifMPI */
+
+   if (pvalue->m.cifMPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cifMPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cif4MPI */
+
+   if (pvalue->m.cif4MPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cif4MPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode cif16MPI */
+
+   if (pvalue->m.cif16MPIPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->cif16MPI, 1U, 32U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode maxBitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 1U, 192400U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode unrestrictedVector */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unrestrictedVector);
+   if (stat != ASN_OK) return stat;
+
+   /* encode arithmeticCoding */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->arithmeticCoding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode advancedPrediction */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedPrediction);
+   if (stat != ASN_OK) return stat;
+
+   /* encode pbFrames */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->pbFrames);
+   if (stat != ASN_OK) return stat;
+
+   /* encode temporalSpatialTradeOffCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->temporalSpatialTradeOffCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode hrd_B */
+
+   if (pvalue->m.hrd_BPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->hrd_B, 0U, 524287U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode bppMaxKb */
+
+   if (pvalue->m.bppMaxKbPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->bppMaxKb, 0U, 65535U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowSqcifMPIPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowQcifMPIPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCifMPIPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCif4MPIPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCif16MPIPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.errorCompensationPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.enhancementLayerInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263OptionsPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.slowSqcifMPIPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->slowSqcifMPI, 1U, 3600U);
+         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.slowQcifMPIPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->slowQcifMPI, 1U, 3600U);
+         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.slowCifMPIPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->slowCifMPI, 1U, 3600U);
+         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.slowCif4MPIPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->slowCif4MPI, 1U, 3600U);
+         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.slowCif16MPIPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->slowCif16MPI, 1U, 3600U);
+         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.errorCompensationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->errorCompensation);
+         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.enhancementLayerInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245EnhancementLayerInfo (&lctxt, &pvalue->enhancementLayerInfo);
+         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.h263OptionsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245H263Options (&lctxt, &pvalue->h263Options);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172VideoCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS11172VideoCapability (OOCTXT* pctxt, H245IS11172VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.videoBadMBsCapPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBitRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.vbvBufferSizePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.samplesPerLinePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.linesPerFramePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.pictureRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.luminanceSampleRatePresent);
+
+   /* encode constrainedBitstream */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->constrainedBitstream);
+   if (stat != ASN_OK) return stat;
+
+   /* encode videoBitRate */
+
+   if (pvalue->m.videoBitRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->videoBitRate, 0U, 1073741823U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode vbvBufferSize */
+
+   if (pvalue->m.vbvBufferSizePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->vbvBufferSize, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode samplesPerLine */
+
+   if (pvalue->m.samplesPerLinePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->samplesPerLine, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode linesPerFrame */
+
+   if (pvalue->m.linesPerFramePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->linesPerFrame, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode pictureRate */
+
+   if (pvalue->m.pictureRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->pictureRate, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode luminanceSampleRate */
+
+   if (pvalue->m.luminanceSampleRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX);
+      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.videoBadMBsCapPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.videoBadMBsCapPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoBadMBsCap);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VideoCapability                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VideoCapability (OOCTXT* pctxt, H245VideoCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h261VideoCapability */
+         case 2:
+            stat = asn1PE_H245H261VideoCapability (pctxt, pvalue->u.h261VideoCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h262VideoCapability */
+         case 3:
+            stat = asn1PE_H245H262VideoCapability (pctxt, pvalue->u.h262VideoCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h263VideoCapability */
+         case 4:
+            stat = asn1PE_H245H263VideoCapability (pctxt, pvalue->u.h263VideoCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* is11172VideoCapability */
+         case 5:
+            stat = asn1PE_H245IS11172VideoCapability (pctxt, pvalue->u.is11172VideoCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* genericVideoCapability */
+         case 6:
+            stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericVideoCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioCapability_g7231                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245AudioCapability_g7231 (OOCTXT* pctxt, H245AudioCapability_g7231* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode maxAl_sduAudioFrames */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxAl_sduAudioFrames, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode silenceSuppression */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->silenceSuppression);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS11172AudioCapability (OOCTXT* pctxt, H245IS11172AudioCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode audioLayer1 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer1);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioLayer2 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer2);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioLayer3 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer3);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling32k */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling32k);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling44k1 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling44k1);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling48k */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling48k);
+   if (stat != ASN_OK) return stat;
+
+   /* encode singleChannel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->singleChannel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode twoChannels */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->twoChannels);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 448U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS13818AudioCapability (OOCTXT* pctxt, H245IS13818AudioCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode audioLayer1 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer1);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioLayer2 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer2);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioLayer3 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer3);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling16k */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling16k);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling22k05 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling22k05);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling24k */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling24k);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling32k */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling32k);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling44k1 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling44k1);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling48k */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling48k);
+   if (stat != ASN_OK) return stat;
+
+   /* encode singleChannel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->singleChannel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode twoChannels */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->twoChannels);
+   if (stat != ASN_OK) return stat;
+
+   /* encode threeChannels2_1 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->threeChannels2_1);
+   if (stat != ASN_OK) return stat;
+
+   /* encode threeChannels3_0 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->threeChannels3_0);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fourChannels2_0_2_0 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fourChannels2_0_2_0);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fourChannels2_2 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fourChannels2_2);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fourChannels3_1 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fourChannels3_1);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fiveChannels3_0_2_0 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fiveChannels3_0_2_0);
+   if (stat != ASN_OK) return stat;
+
+   /* encode fiveChannels3_2 */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fiveChannels3_2);
+   if (stat != ASN_OK) return stat;
+
+   /* encode lowFrequencyEnhancement */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->lowFrequencyEnhancement);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multilingual */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multilingual);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 1130U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCCapability_g723AnnexCAudioMode                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245G7231AnnexCCapability_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCCapability_g723AnnexCAudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode highRateMode0 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->highRateMode0, 27U, 78U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode highRateMode1 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->highRateMode1, 27U, 78U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode lowRateMode0 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->lowRateMode0, 23U, 66U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode lowRateMode1 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->lowRateMode1, 23U, 66U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sidMode0 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sidMode0, 6U, 17U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sidMode1 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sidMode1, 6U, 17U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCCapability                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245G7231AnnexCCapability (OOCTXT* pctxt, H245G7231AnnexCCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.g723AnnexCAudioModePresent);
+
+   /* encode maxAl_sduAudioFrames */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxAl_sduAudioFrames, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode silenceSuppression */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->silenceSuppression);
+   if (stat != ASN_OK) return stat;
+
+   /* encode g723AnnexCAudioMode */
+
+   if (pvalue->m.g723AnnexCAudioModePresent) {
+      stat = asn1PE_H245G7231AnnexCCapability_g723AnnexCAudioMode (pctxt, &pvalue->g723AnnexCAudioMode);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  GSMAudioCapability                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245GSMAudioCapability (OOCTXT* pctxt, H245GSMAudioCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode audioUnitSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->audioUnitSize, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode comfortNoise */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->comfortNoise);
+   if (stat != ASN_OK) return stat;
+
+   /* encode scrambled */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->scrambled);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G729Extensions                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245G729Extensions (OOCTXT* pctxt, H245G729Extensions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.audioUnitPresent);
+
+   /* encode audioUnit */
+
+   if (pvalue->m.audioUnitPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->audioUnit, 1U, 256U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode annexA */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexA);
+   if (stat != ASN_OK) return stat;
+
+   /* encode annexB */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexB);
+   if (stat != ASN_OK) return stat;
+
+   /* encode annexD */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexD);
+   if (stat != ASN_OK) return stat;
+
+   /* encode annexE */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexE);
+   if (stat != ASN_OK) return stat;
+
+   /* encode annexF */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexF);
+   if (stat != ASN_OK) return stat;
+
+   /* encode annexG */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexG);
+   if (stat != ASN_OK) return stat;
+
+   /* encode annexH */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexH);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VBDCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VBDCapability (OOCTXT* pctxt, H245VBDCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = asn1PE_H245AudioCapability (pctxt, (H245AudioCapability*)pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NoPTAudioTelephonyEventCapability                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NoPTAudioTelephonyEventCapability (OOCTXT* pctxt, H245NoPTAudioTelephonyEventCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode audioTelephoneEvent */
+
+   stat = encodeVarWidthCharString (pctxt, pvalue->audioTelephoneEvent);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NoPTAudioToneCapability                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NoPTAudioToneCapability (OOCTXT* pctxt, H245NoPTAudioToneCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioCapability                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245AudioCapability (OOCTXT* pctxt, H245AudioCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 14);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 13);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* g711Alaw64k */
+         case 2:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g711Alaw64k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g711Alaw56k */
+         case 3:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g711Alaw56k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g711Ulaw64k */
+         case 4:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g711Ulaw64k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g711Ulaw56k */
+         case 5:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g711Ulaw56k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g722_64k */
+         case 6:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g722_64k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g722_56k */
+         case 7:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g722_56k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g722_48k */
+         case 8:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g722_48k, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g7231 */
+         case 9:
+            stat = asn1PE_H245AudioCapability_g7231 (pctxt, pvalue->u.g7231);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* g728 */
+         case 10:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g728, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g729 */
+         case 11:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g729, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* g729AnnexA */
+         case 12:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.g729AnnexA, 1U, 256U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* is11172AudioCapability */
+         case 13:
+            stat = asn1PE_H245IS11172AudioCapability (pctxt, pvalue->u.is11172AudioCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* is13818AudioCapability */
+         case 14:
+            stat = asn1PE_H245IS13818AudioCapability (pctxt, pvalue->u.is13818AudioCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 15);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* g729wAnnexB */
+         case 15:
+            stat = encodeConsUnsigned (&lctxt, pvalue->u.g729wAnnexB, 1U, 256U);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* g729AnnexAwAnnexB */
+         case 16:
+            stat = encodeConsUnsigned (&lctxt, pvalue->u.g729AnnexAwAnnexB, 1U, 256U);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* g7231AnnexCCapability */
+         case 17:
+            stat = asn1PE_H245G7231AnnexCCapability (&lctxt, pvalue->u.g7231AnnexCCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* gsmFullRate */
+         case 18:
+            stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmFullRate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* gsmHalfRate */
+         case 19:
+            stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmHalfRate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* gsmEnhancedFullRate */
+         case 20:
+            stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmEnhancedFullRate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericAudioCapability */
+         case 21:
+            stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericAudioCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* g729Extensions */
+         case 22:
+            stat = asn1PE_H245G729Extensions (&lctxt, pvalue->u.g729Extensions);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* vbd */
+         case 23:
+            stat = asn1PE_H245VBDCapability (&lctxt, pvalue->u.vbd);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* audioTelephonyEvent */
+         case 24:
+            stat = asn1PE_H245NoPTAudioTelephonyEventCapability (&lctxt, pvalue->u.audioTelephonyEvent);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* audioTone */
+         case 25:
+            stat = asn1PE_H245NoPTAudioToneCapability (&lctxt, pvalue->u.audioTone);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Capability_h233EncryptionReceiveCapability                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245Capability_h233EncryptionReceiveCapability (OOCTXT* pctxt, H245Capability_h233EncryptionReceiveCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode h233IVResponseTime */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->h233IVResponseTime, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245NonStandardParameter                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245NonStandardParameter (OOCTXT* pctxt, H245_SeqOfH245NonStandardParameter* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245NonStandardParameter (pctxt, ((H245NonStandardParameter*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceCapability (OOCTXT* pctxt, H245ConferenceCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.videoIndicateMixingCapabilityPresent ||
+   pvalue->m.multipointVisualizationCapabilityPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
+
+   /* encode nonStandardData */
+
+   if (pvalue->m.nonStandardDataPresent) {
+      stat = asn1PE_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandardData);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode chairControlCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->chairControlCapability);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoIndicateMixingCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipointVisualizationCapabilityPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.videoIndicateMixingCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoIndicateMixingCapability);
+         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.multipointVisualizationCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipointVisualizationCapability);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MediaEncryptionAlgorithm                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MediaEncryptionAlgorithm (OOCTXT* pctxt, H245MediaEncryptionAlgorithm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* algorithm */
+         case 2:
+            stat = encodeObjectIdentifier (pctxt, pvalue->u.algorithm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCapability                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EncryptionCapability (OOCTXT* pctxt, H245EncryptionCapability* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245MediaEncryptionAlgorithm (pctxt, ((H245MediaEncryptionAlgorithm*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AuthenticationCapability                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245AuthenticationCapability (OOCTXT* pctxt, H245AuthenticationCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.antiSpamAlgorithmPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      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.antiSpamAlgorithmPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.antiSpamAlgorithmPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeObjectIdentifier (&lctxt, &pvalue->antiSpamAlgorithm);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IntegrityCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IntegrityCapability (OOCTXT* pctxt, H245IntegrityCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionAuthenticationAndIntegrity                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EncryptionAuthenticationAndIntegrity (OOCTXT* pctxt, H245EncryptionAuthenticationAndIntegrity* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.encryptionCapabilityPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.authenticationCapabilityPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCapabilityPresent);
+
+   /* encode encryptionCapability */
+
+   if (pvalue->m.encryptionCapabilityPresent) {
+      stat = asn1PE_H245EncryptionCapability (pctxt, &pvalue->encryptionCapability);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode authenticationCapability */
+
+   if (pvalue->m.authenticationCapabilityPresent) {
+      stat = asn1PE_H245AuthenticationCapability (pctxt, &pvalue->authenticationCapability);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode integrityCapability */
+
+   if (pvalue->m.integrityCapabilityPresent) {
+      stat = asn1PE_H245IntegrityCapability (pctxt, &pvalue->integrityCapability);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235SecurityCapability                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H235SecurityCapability (OOCTXT* pctxt, H245H235SecurityCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode encryptionAuthenticationAndIntegrity */
+
+   stat = asn1PE_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mediaCapability */
+
+   stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->mediaCapability);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputCapability_nonStandard                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UserInputCapability_nonStandard (OOCTXT* pctxt, H245UserInputCapability_nonStandard* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245NonStandardParameter (pctxt, ((H245NonStandardParameter*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UserInputCapability (OOCTXT* pctxt, H245UserInputCapability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245UserInputCapability_nonStandard (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* basicString */
+         case 2:
+            /* NULL */
+            break;
+
+         /* iA5String */
+         case 3:
+            /* NULL */
+            break;
+
+         /* generalString */
+         case 4:
+            /* NULL */
+            break;
+
+         /* dtmf */
+         case 5:
+            /* NULL */
+            break;
+
+         /* hookflash */
+         case 6:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* extendedAlphanumeric */
+         case 7:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexFormat                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexFormat (OOCTXT* pctxt, H245MultiplexFormat* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h222Capability */
+         case 2:
+            stat = asn1PE_H245H222Capability (pctxt, pvalue->u.h222Capability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h223Capability */
+         case 3:
+            stat = asn1PE_H245H223Capability (pctxt, pvalue->u.h223Capability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AlternativeCapabilitySet                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245AlternativeCapabilitySet (OOCTXT* pctxt, H245AlternativeCapabilitySet* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamCapability_capabilityOnMuxStream         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexedStreamCapability_capabilityOnMuxStream (OOCTXT* pctxt, H245MultiplexedStreamCapability_capabilityOnMuxStream* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245AlternativeCapabilitySet (pctxt, ((H245AlternativeCapabilitySet*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamCapability                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexedStreamCapability (OOCTXT* pctxt, H245MultiplexedStreamCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityOnMuxStreamPresent);
+
+   /* encode multiplexFormat */
+
+   stat = asn1PE_H245MultiplexFormat (pctxt, &pvalue->multiplexFormat);
+   if (stat != ASN_OK) return stat;
+
+   /* encode controlOnMuxStream */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->controlOnMuxStream);
+   if (stat != ASN_OK) return stat;
+
+   /* encode capabilityOnMuxStream */
+
+   if (pvalue->m.capabilityOnMuxStreamPresent) {
+      stat = asn1PE_H245MultiplexedStreamCapability_capabilityOnMuxStream (pctxt, &pvalue->capabilityOnMuxStream);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioTelephonyEventCapability                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245AudioTelephonyEventCapability (OOCTXT* pctxt, H245AudioTelephonyEventCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode dynamicRTPPayloadType */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->dynamicRTPPayloadType, 96U, 127U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioTelephoneEvent */
+
+   stat = encodeVarWidthCharString (pctxt, pvalue->audioTelephoneEvent);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioToneCapability                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245AudioToneCapability (OOCTXT* pctxt, H245AudioToneCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode dynamicRTPPayloadType */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->dynamicRTPPayloadType, 96U, 127U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability_rfc2733_separateStream                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECCapability_rfc2733_separateStream (OOCTXT* pctxt, H245FECCapability_rfc2733_separateStream* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode separatePort */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->separatePort);
+   if (stat != ASN_OK) return stat;
+
+   /* encode samePort */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->samePort);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability_rfc2733                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECCapability_rfc2733 (OOCTXT* pctxt, H245FECCapability_rfc2733* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode redundancyEncoding */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->redundancyEncoding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode separateStream */
+
+   stat = asn1PE_H245FECCapability_rfc2733_separateStream (pctxt, &pvalue->separateStream);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECCapability                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECCapability (OOCTXT* pctxt, H245FECCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* rfc2733 */
+         case 1:
+            stat = asn1PE_H245FECCapability_rfc2733 (pctxt, pvalue->u.rfc2733);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamCapability_capabilities              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplePayloadStreamCapability_capabilities (OOCTXT* pctxt, H245MultiplePayloadStreamCapability_capabilities* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245AlternativeCapabilitySet (pctxt, ((H245AlternativeCapabilitySet*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamCapability                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplePayloadStreamCapability (OOCTXT* pctxt, H245MultiplePayloadStreamCapability* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode capabilities */
+
+   stat = asn1PE_H245MultiplePayloadStreamCapability_capabilities (pctxt, &pvalue->capabilities);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Capability                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245Capability (OOCTXT* pctxt, H245Capability* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 12);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 11);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* receiveVideoCapability */
+         case 2:
+            stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.receiveVideoCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* transmitVideoCapability */
+         case 3:
+            stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.transmitVideoCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* receiveAndTransmitVideoCapability */
+         case 4:
+            stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.receiveAndTransmitVideoCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* receiveAudioCapability */
+         case 5:
+            stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.receiveAudioCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* transmitAudioCapability */
+         case 6:
+            stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.transmitAudioCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* receiveAndTransmitAudioCapability */
+         case 7:
+            stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.receiveAndTransmitAudioCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* receiveDataApplicationCapability */
+         case 8:
+            stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.receiveDataApplicationCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* transmitDataApplicationCapability */
+         case 9:
+            stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.transmitDataApplicationCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* receiveAndTransmitDataApplicationCapability */
+         case 10:
+            stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.receiveAndTransmitDataApplicationCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h233EncryptionTransmitCapability */
+         case 11:
+            stat = encodeBit (pctxt, (ASN1BOOL)pvalue->u.h233EncryptionTransmitCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h233EncryptionReceiveCapability */
+         case 12:
+            stat = asn1PE_H245Capability_h233EncryptionReceiveCapability (pctxt, pvalue->u.h233EncryptionReceiveCapability);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 13);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* conferenceCapability */
+         case 13:
+            stat = asn1PE_H245ConferenceCapability (&lctxt, pvalue->u.conferenceCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* h235SecurityCapability */
+         case 14:
+            stat = asn1PE_H245H235SecurityCapability (&lctxt, pvalue->u.h235SecurityCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* maxPendingReplacementFor */
+         case 15:
+            stat = encodeConsUnsigned (&lctxt, pvalue->u.maxPendingReplacementFor, 0U, 255U);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* receiveUserInputCapability */
+         case 16:
+            stat = asn1PE_H245UserInputCapability (&lctxt, pvalue->u.receiveUserInputCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* transmitUserInputCapability */
+         case 17:
+            stat = asn1PE_H245UserInputCapability (&lctxt, pvalue->u.transmitUserInputCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* receiveAndTransmitUserInputCapability */
+         case 18:
+            stat = asn1PE_H245UserInputCapability (&lctxt, pvalue->u.receiveAndTransmitUserInputCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericControlCapability */
+         case 19:
+            stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericControlCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* receiveMultiplexedStreamCapability */
+         case 20:
+            stat = asn1PE_H245MultiplexedStreamCapability (&lctxt, pvalue->u.receiveMultiplexedStreamCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* transmitMultiplexedStreamCapability */
+         case 21:
+            stat = asn1PE_H245MultiplexedStreamCapability (&lctxt, pvalue->u.transmitMultiplexedStreamCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* receiveAndTransmitMultiplexedStreamCapability */
+         case 22:
+            stat = asn1PE_H245MultiplexedStreamCapability (&lctxt, pvalue->u.receiveAndTransmitMultiplexedStreamCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* receiveRTPAudioTelephonyEventCapability */
+         case 23:
+            stat = asn1PE_H245AudioTelephonyEventCapability (&lctxt, pvalue->u.receiveRTPAudioTelephonyEventCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* receiveRTPAudioToneCapability */
+         case 24:
+            stat = asn1PE_H245AudioToneCapability (&lctxt, pvalue->u.receiveRTPAudioToneCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* fecCapability */
+         case 25:
+            stat = asn1PE_H245FECCapability (&lctxt, pvalue->u.fecCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multiplePayloadStreamCapability */
+         case 26:
+            stat = asn1PE_H245MultiplePayloadStreamCapability (&lctxt, pvalue->u.multiplePayloadStreamCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityTableEntry                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CapabilityTableEntry (OOCTXT* pctxt, H245CapabilityTableEntry* pvalue)
+{
+   int stat = ASN_OK;
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityPresent);
+
+   /* encode capabilityTableEntryNumber */
+
+   stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->capabilityTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode capability */
+
+   if (pvalue->m.capabilityPresent) {
+      stat = asn1PE_H245Capability (pctxt, &pvalue->capability);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet_capabilityTable                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalCapabilitySet_capabilityTable (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityTable* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245CapabilityTableEntry (pctxt, ((H245CapabilityTableEntry*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptorNumber                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CapabilityDescriptorNumber (OOCTXT* pctxt, H245CapabilityDescriptorNumber value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptor_simultaneousCapabilities             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CapabilityDescriptor_simultaneousCapabilities (OOCTXT* pctxt, H245CapabilityDescriptor_simultaneousCapabilities* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245AlternativeCapabilitySet (pctxt, ((H245AlternativeCapabilitySet*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CapabilityDescriptor                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CapabilityDescriptor (OOCTXT* pctxt, H245CapabilityDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.simultaneousCapabilitiesPresent);
+
+   /* encode capabilityDescriptorNumber */
+
+   stat = asn1PE_H245CapabilityDescriptorNumber (pctxt, pvalue->capabilityDescriptorNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode simultaneousCapabilities */
+
+   if (pvalue->m.simultaneousCapabilitiesPresent) {
+      stat = asn1PE_H245CapabilityDescriptor_simultaneousCapabilities (pctxt, &pvalue->simultaneousCapabilities);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet_capabilityDescriptors               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalCapabilitySet_capabilityDescriptors (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityDescriptors* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245CapabilityDescriptor (pctxt, ((H245CapabilityDescriptor*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySet                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalCapabilitySet (OOCTXT* pctxt, H245TerminalCapabilitySet* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.multiplexCapabilityPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityTablePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityDescriptorsPresent);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protocolIdentifier */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->protocolIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplexCapability */
+
+   if (pvalue->m.multiplexCapabilityPresent) {
+      stat = asn1PE_H245MultiplexCapability (pctxt, &pvalue->multiplexCapability);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode capabilityTable */
+
+   if (pvalue->m.capabilityTablePresent) {
+      stat = asn1PE_H245TerminalCapabilitySet_capabilityTable (pctxt, &pvalue->capabilityTable);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode capabilityDescriptors */
+
+   if (pvalue->m.capabilityDescriptorsPresent) {
+      stat = asn1PE_H245TerminalCapabilitySet_capabilityDescriptors (pctxt, &pvalue->capabilityDescriptors);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelNumber                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245LogicalChannelNumber (OOCTXT* pctxt, H245LogicalChannelNumber value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionMode                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EncryptionMode (OOCTXT* pctxt, H245EncryptionMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h233Encryption */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingElement                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingElement (OOCTXT* pctxt, H245RedundancyEncodingElement* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.payloadTypePresent);
+
+   /* encode dataType */
+
+   stat = asn1PE_H245DataType (pctxt, (H245DataType*)pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode payloadType */
+
+   if (pvalue->m.payloadTypePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->payloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245RedundancyEncodingElement                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245RedundancyEncodingElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingElement* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245RedundancyEncodingElement (pctxt, ((H245RedundancyEncodingElement*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncoding_rtpRedundancyEncoding                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncoding_rtpRedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding_rtpRedundancyEncoding* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.primaryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.secondaryPresent);
+
+   /* encode primary */
+
+   if (pvalue->m.primaryPresent) {
+      stat = asn1PE_H245RedundancyEncodingElement (pctxt, &pvalue->primary);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode secondary */
+
+   if (pvalue->m.secondaryPresent) {
+      stat = asn1PE_H245_SeqOfH245RedundancyEncodingElement (pctxt, &pvalue->secondary);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncoding                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.rtpRedundancyEncodingPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.secondaryEncodingPresent);
+
+   /* encode redundancyEncodingMethod */
+
+   stat = asn1PE_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod);
+   if (stat != ASN_OK) return stat;
+
+   /* encode secondaryEncoding */
+
+   if (pvalue->m.secondaryEncodingPresent) {
+      stat = asn1PE_H245DataType (pctxt, (H245DataType*)pvalue->secondaryEncoding);
+      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.rtpRedundancyEncodingPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.rtpRedundancyEncodingPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245RedundancyEncoding_rtpRedundancyEncoding (&lctxt, &pvalue->rtpRedundancyEncoding);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamElement                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplePayloadStreamElement (OOCTXT* pctxt, H245MultiplePayloadStreamElement* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.payloadTypePresent);
+
+   /* encode dataType */
+
+   stat = asn1PE_H245DataType (pctxt, (H245DataType*)pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode payloadType */
+
+   if (pvalue->m.payloadTypePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->payloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MultiplePayloadStreamElement                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245MultiplePayloadStreamElement (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElement* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245MultiplePayloadStreamElement (pctxt, ((H245MultiplePayloadStreamElement*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStream                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplePayloadStream (OOCTXT* pctxt, H245MultiplePayloadStream* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode elements */
+
+   stat = asn1PE_H245_SeqOfH245MultiplePayloadStreamElement (pctxt, &pvalue->elements);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream_differentPort         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_differentPort* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.protectedPayloadTypePresent);
+
+   /* encode protectedSessionID */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->protectedSessionID, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protectedPayloadType */
+
+   if (pvalue->m.protectedPayloadTypePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->protectedPayloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream_samePort              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream_samePort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_samePort* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode protectedPayloadType */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->protectedPayloadType, 0U, 127U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode_separateStream                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* differentPort */
+         case 1:
+            stat = asn1PE_H245FECData_rfc2733_mode_separateStream_differentPort (pctxt, pvalue->u.differentPort);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* samePort */
+         case 2:
+            stat = asn1PE_H245FECData_rfc2733_mode_separateStream_samePort (pctxt, pvalue->u.samePort);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733_mode                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECData_rfc2733_mode (OOCTXT* pctxt, H245FECData_rfc2733_mode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* redundancyEncoding */
+         case 1:
+            /* NULL */
+            break;
+
+         /* separateStream */
+         case 2:
+            stat = asn1PE_H245FECData_rfc2733_mode_separateStream (pctxt, pvalue->u.separateStream);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData_rfc2733                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECData_rfc2733 (OOCTXT* pctxt, H245FECData_rfc2733* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode mode */
+
+   stat = asn1PE_H245FECData_rfc2733_mode (pctxt, &pvalue->mode);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECData                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECData (OOCTXT* pctxt, H245FECData* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* rfc2733 */
+      case 1:
+         stat = asn1PE_H245FECData_rfc2733 (pctxt, pvalue->u.rfc2733);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235Media_mediaType                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H235Media_mediaType (OOCTXT* pctxt, H245H235Media_mediaType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* videoData */
+         case 2:
+            stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.videoData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* audioData */
+         case 3:
+            stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.audioData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* data */
+         case 4:
+            stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.data);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* redundancyEncoding */
+         case 5:
+            stat = asn1PE_H245RedundancyEncoding (&lctxt, pvalue->u.redundancyEncoding);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multiplePayloadStream */
+         case 6:
+            stat = asn1PE_H245MultiplePayloadStream (&lctxt, pvalue->u.multiplePayloadStream);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* fec */
+         case 7:
+            stat = asn1PE_H245FECData (&lctxt, pvalue->u.fec);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235Media                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H235Media (OOCTXT* pctxt, H245H235Media* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode encryptionAuthenticationAndIntegrity */
+
+   stat = asn1PE_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mediaType */
+
+   stat = asn1PE_H245H235Media_mediaType (pctxt, &pvalue->mediaType);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamParameter                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexedStreamParameter (OOCTXT* pctxt, H245MultiplexedStreamParameter* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode multiplexFormat */
+
+   stat = asn1PE_H245MultiplexFormat (pctxt, &pvalue->multiplexFormat);
+   if (stat != ASN_OK) return stat;
+
+   /* encode controlOnMuxStream */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->controlOnMuxStream);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataType                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataType (OOCTXT* pctxt, H245DataType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nullData */
+         case 2:
+            /* NULL */
+            break;
+
+         /* videoData */
+         case 3:
+            stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.videoData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* audioData */
+         case 4:
+            stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.audioData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* data */
+         case 5:
+            stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.data);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* encryptionData */
+         case 6:
+            stat = asn1PE_H245EncryptionMode (pctxt, pvalue->u.encryptionData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* h235Control */
+         case 7:
+            stat = asn1PE_H245NonStandardParameter (&lctxt, pvalue->u.h235Control);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* h235Media */
+         case 8:
+            stat = asn1PE_H245H235Media (&lctxt, pvalue->u.h235Media);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multiplexedStream */
+         case 9:
+            stat = asn1PE_H245MultiplexedStreamParameter (&lctxt, pvalue->u.multiplexedStream);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* redundancyEncoding */
+         case 10:
+            stat = asn1PE_H245RedundancyEncoding (&lctxt, pvalue->u.redundancyEncoding);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multiplePayloadStream */
+         case 11:
+            stat = asn1PE_H245MultiplePayloadStream (&lctxt, pvalue->u.multiplePayloadStream);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* fec */
+         case 12:
+            stat = asn1PE_H245FECData (&lctxt, pvalue->u.fec);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H222LogicalChannelParameters                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H222LogicalChannelParameters (OOCTXT* pctxt, H245H222LogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.pcr_pidPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.programDescriptorsPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.streamDescriptorsPresent);
+
+   /* encode resourceID */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->resourceID, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode subChannelID */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->subChannelID, 0U, 8191U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode pcr_pid */
+
+   if (pvalue->m.pcr_pidPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->pcr_pid, 0U, 8191U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode programDescriptors */
+
+   if (pvalue->m.programDescriptorsPresent) {
+      stat = encodeOctetString (pctxt, pvalue->programDescriptors.numocts, pvalue->programDescriptors.data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode streamDescriptors */
+
+   if (pvalue->m.streamDescriptorsPresent) {
+      stat = encodeOctetString (pctxt, pvalue->streamDescriptors.numocts, pvalue->streamDescriptors.data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters_adaptationLayerType_al3      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223LogicalChannelParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode controlFieldOctets */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->controlFieldOctets, 0U, 2U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sendBufferSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sendBufferSize, 0U, 16777215U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_transferMode                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL1MParameters_transferMode (OOCTXT* pctxt, H245H223AL1MParameters_transferMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* framed */
+         case 1:
+            /* NULL */
+            break;
+
+         /* unframed */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_headerFEC                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL1MParameters_headerFEC (OOCTXT* pctxt, H245H223AL1MParameters_headerFEC* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* sebch16_7 */
+         case 1:
+            /* NULL */
+            break;
+
+         /* golay24_12 */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_crcLength                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL1MParameters_crcLength (OOCTXT* pctxt, H245H223AL1MParameters_crcLength* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* crc4bit */
+         case 1:
+            /* NULL */
+            break;
+
+         /* crc12bit */
+         case 2:
+            /* NULL */
+            break;
+
+         /* crc20bit */
+         case 3:
+            /* NULL */
+            break;
+
+         /* crc28bit */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* crc8bit */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* crc16bit */
+         case 6:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* crc32bit */
+         case 7:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* crcNotUsed */
+         case 8:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AnnexCArqParameters_numberOfRetransmissions           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AnnexCArqParameters_numberOfRetransmissions (OOCTXT* pctxt, H245H223AnnexCArqParameters_numberOfRetransmissions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* finite */
+         case 1:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.finite, 0U, 16U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* infinite */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AnnexCArqParameters                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AnnexCArqParameters (OOCTXT* pctxt, H245H223AnnexCArqParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode numberOfRetransmissions */
+
+   stat = asn1PE_H245H223AnnexCArqParameters_numberOfRetransmissions (pctxt, &pvalue->numberOfRetransmissions);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sendBufferSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sendBufferSize, 0U, 16777215U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters_arqType                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL1MParameters_arqType (OOCTXT* pctxt, H245H223AL1MParameters_arqType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* noArq */
+         case 1:
+            /* NULL */
+            break;
+
+         /* typeIArq */
+         case 2:
+            stat = asn1PE_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIArq);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* typeIIArq */
+         case 3:
+            stat = asn1PE_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIIArq);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL1MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL1MParameters (OOCTXT* pctxt, H245H223AL1MParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.rsCodeCorrectionPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode transferMode */
+
+   stat = asn1PE_H245H223AL1MParameters_transferMode (pctxt, &pvalue->transferMode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode headerFEC */
+
+   stat = asn1PE_H245H223AL1MParameters_headerFEC (pctxt, &pvalue->headerFEC);
+   if (stat != ASN_OK) return stat;
+
+   /* encode crcLength */
+
+   stat = asn1PE_H245H223AL1MParameters_crcLength (pctxt, &pvalue->crcLength);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rcpcCodeRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->rcpcCodeRate, 8U, 32U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode arqType */
+
+   stat = asn1PE_H245H223AL1MParameters_arqType (pctxt, &pvalue->arqType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alpduInterleaving */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alpduInterleaving);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alsduSplitting */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alsduSplitting);
+   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.rsCodeCorrectionPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.rsCodeCorrectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->rsCodeCorrection, 0U, 127U);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL2MParameters_headerFEC                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL2MParameters_headerFEC (OOCTXT* pctxt, H245H223AL2MParameters_headerFEC* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* sebch16_5 */
+         case 1:
+            /* NULL */
+            break;
+
+         /* golay24_12 */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL2MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL2MParameters (OOCTXT* pctxt, H245H223AL2MParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode headerFEC */
+
+   stat = asn1PE_H245H223AL2MParameters_headerFEC (pctxt, &pvalue->headerFEC);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alpduInterleaving */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alpduInterleaving);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_headerFormat                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL3MParameters_headerFormat (OOCTXT* pctxt, H245H223AL3MParameters_headerFormat* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* sebch16_7 */
+         case 1:
+            /* NULL */
+            break;
+
+         /* golay24_12 */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_crcLength                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL3MParameters_crcLength (OOCTXT* pctxt, H245H223AL3MParameters_crcLength* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* crc4bit */
+         case 1:
+            /* NULL */
+            break;
+
+         /* crc12bit */
+         case 2:
+            /* NULL */
+            break;
+
+         /* crc20bit */
+         case 3:
+            /* NULL */
+            break;
+
+         /* crc28bit */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* crc8bit */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* crc16bit */
+         case 6:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* crc32bit */
+         case 7:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* crcNotUsed */
+         case 8:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters_arqType                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL3MParameters_arqType (OOCTXT* pctxt, H245H223AL3MParameters_arqType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* noArq */
+         case 1:
+            /* NULL */
+            break;
+
+         /* typeIArq */
+         case 2:
+            stat = asn1PE_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIArq);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* typeIIArq */
+         case 3:
+            stat = asn1PE_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIIArq);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223AL3MParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223AL3MParameters (OOCTXT* pctxt, H245H223AL3MParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.rsCodeCorrectionPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode headerFormat */
+
+   stat = asn1PE_H245H223AL3MParameters_headerFormat (pctxt, &pvalue->headerFormat);
+   if (stat != ASN_OK) return stat;
+
+   /* encode crcLength */
+
+   stat = asn1PE_H245H223AL3MParameters_crcLength (pctxt, &pvalue->crcLength);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rcpcCodeRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->rcpcCodeRate, 8U, 32U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode arqType */
+
+   stat = asn1PE_H245H223AL3MParameters_arqType (pctxt, &pvalue->arqType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode alpduInterleaving */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alpduInterleaving);
+   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.rsCodeCorrectionPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.rsCodeCorrectionPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->rsCodeCorrection, 0U, 127U);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters_adaptationLayerType          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223LogicalChannelParameters_adaptationLayerType (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* al1Framed */
+         case 2:
+            /* NULL */
+            break;
+
+         /* al1NotFramed */
+         case 3:
+            /* NULL */
+            break;
+
+         /* al2WithoutSequenceNumbers */
+         case 4:
+            /* NULL */
+            break;
+
+         /* al2WithSequenceNumbers */
+         case 5:
+            /* NULL */
+            break;
+
+         /* al3 */
+         case 6:
+            stat = asn1PE_H245H223LogicalChannelParameters_adaptationLayerType_al3 (pctxt, pvalue->u.al3);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* al1M */
+         case 7:
+            stat = asn1PE_H245H223AL1MParameters (&lctxt, pvalue->u.al1M);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* al2M */
+         case 8:
+            stat = asn1PE_H245H223AL2MParameters (&lctxt, pvalue->u.al2M);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* al3M */
+         case 9:
+            stat = asn1PE_H245H223AL3MParameters (&lctxt, pvalue->u.al3M);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223LogicalChannelParameters                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223LogicalChannelParameters (OOCTXT* pctxt, H245H223LogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode adaptationLayerType */
+
+   stat = asn1PE_H245H223LogicalChannelParameters_adaptationLayerType (pctxt, &pvalue->adaptationLayerType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode segmentableFlag */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->segmentableFlag);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CRCLength                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CRCLength (OOCTXT* pctxt, H245CRCLength* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* crc8bit */
+         case 1:
+            /* NULL */
+            break;
+
+         /* crc16bit */
+         case 2:
+            /* NULL */
+            break;
+
+         /* crc32bit */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76HDLCParameters                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V76HDLCParameters (OOCTXT* pctxt, H245V76HDLCParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode crcLength */
+
+   stat = asn1PE_H245CRCLength (pctxt, &pvalue->crcLength);
+   if (stat != ASN_OK) return stat;
+
+   /* encode n401 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->n401, 1U, 4095U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode loopbackTestProcedure */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->loopbackTestProcedure);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_suspendResume                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters_suspendResume (OOCTXT* pctxt, H245V76LogicalChannelParameters_suspendResume* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* noSuspendResume */
+         case 1:
+            /* NULL */
+            break;
+
+         /* suspendResumewAddress */
+         case 2:
+            /* NULL */
+            break;
+
+         /* suspendResumewoAddress */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode_eRM_recovery             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters_mode_eRM_recovery (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM_recovery* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* rej */
+         case 1:
+            /* NULL */
+            break;
+
+         /* sREJ */
+         case 2:
+            /* NULL */
+            break;
+
+         /* mSREJ */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode_eRM                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters_mode_eRM (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode windowSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->windowSize, 1U, 127U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode recovery */
+
+   stat = asn1PE_H245V76LogicalChannelParameters_mode_eRM_recovery (pctxt, &pvalue->recovery);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters_mode                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters_mode (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* eRM */
+         case 1:
+            stat = asn1PE_H245V76LogicalChannelParameters_mode_eRM (pctxt, pvalue->u.eRM);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* uNERM */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V75Parameters                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V75Parameters (OOCTXT* pctxt, H245V75Parameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode audioHeaderPresent */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioHeaderPresent);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76LogicalChannelParameters                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V76LogicalChannelParameters (OOCTXT* pctxt, H245V76LogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode hdlcParameters */
+
+   stat = asn1PE_H245V76HDLCParameters (pctxt, &pvalue->hdlcParameters);
+   if (stat != ASN_OK) return stat;
+
+   /* encode suspendResume */
+
+   stat = asn1PE_H245V76LogicalChannelParameters_suspendResume (pctxt, &pvalue->suspendResume);
+   if (stat != ASN_OK) return stat;
+
+   /* encode uIH */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->uIH);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mode */
+
+   stat = asn1PE_H245V76LogicalChannelParameters_mode (pctxt, &pvalue->mode);
+   if (stat != ASN_OK) return stat;
+
+   /* encode v75Parameters */
+
+   stat = asn1PE_H245V75Parameters (pctxt, &pvalue->v75Parameters);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPAddress_network                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPAddress_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPAddress                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPAddress (OOCTXT* pctxt, H245UnicastAddress_iPAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode network */
+
+   stat = asn1PE_H245UnicastAddress_iPAddress_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tsapIdentifier */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_node                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPXAddress_node (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_node* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_netnum                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPXAddress_netnum (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_netnum* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress_tsapIdentifier                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPXAddress_tsapIdentifier (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_tsapIdentifier* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPXAddress                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPXAddress (OOCTXT* pctxt, H245UnicastAddress_iPXAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode node */
+
+   stat = asn1PE_H245UnicastAddress_iPXAddress_node (pctxt, &pvalue->node);
+   if (stat != ASN_OK) return stat;
+
+   /* encode netnum */
+
+   stat = asn1PE_H245UnicastAddress_iPXAddress_netnum (pctxt, &pvalue->netnum);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tsapIdentifier */
+
+   stat = asn1PE_H245UnicastAddress_iPXAddress_tsapIdentifier (pctxt, &pvalue->tsapIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iP6Address_network                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iP6Address_network (OOCTXT* pctxt, H245UnicastAddress_iP6Address_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iP6Address                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iP6Address (OOCTXT* pctxt, H245UnicastAddress_iP6Address* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode network */
+
+   stat = asn1PE_H245UnicastAddress_iP6Address_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tsapIdentifier */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_netBios                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_netBios (OOCTXT* pctxt, H245UnicastAddress_netBios* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_routing               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_routing (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_routing* 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)
+   {
+      /* strict */
+      case 1:
+         /* NULL */
+         break;
+
+      /* loose */
+      case 2:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_network               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress_route_element         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_route_element* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245UnicastAddress_iPSourceRouteAddress_route_elem  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245UnicastAddress_iPSourceRouteAddress_route_element (pctxt, &pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_iPSourceRouteAddress                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode routing */
+
+   stat = asn1PE_H245UnicastAddress_iPSourceRouteAddress_routing (pctxt, &pvalue->routing);
+   if (stat != ASN_OK) return stat;
+
+   /* encode network */
+
+   stat = asn1PE_H245UnicastAddress_iPSourceRouteAddress_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tsapIdentifier */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode route */
+
+   stat = asn1PE_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (pctxt, &pvalue->route);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress_nsap                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress_nsap (OOCTXT* pctxt, H245UnicastAddress_nsap* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UnicastAddress                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UnicastAddress (OOCTXT* pctxt, H245UnicastAddress* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* iPAddress */
+         case 1:
+            stat = asn1PE_H245UnicastAddress_iPAddress (pctxt, pvalue->u.iPAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* iPXAddress */
+         case 2:
+            stat = asn1PE_H245UnicastAddress_iPXAddress (pctxt, pvalue->u.iPXAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* iP6Address */
+         case 3:
+            stat = asn1PE_H245UnicastAddress_iP6Address (pctxt, pvalue->u.iP6Address);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* netBios */
+         case 4:
+            stat = asn1PE_H245UnicastAddress_netBios (pctxt, pvalue->u.netBios);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* iPSourceRouteAddress */
+         case 5:
+            stat = asn1PE_H245UnicastAddress_iPSourceRouteAddress (pctxt, pvalue->u.iPSourceRouteAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* nsap */
+         case 6:
+            stat = asn1PE_H245UnicastAddress_nsap (&lctxt, pvalue->u.nsap);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* nonStandardAddress */
+         case 7:
+            stat = asn1PE_H245NonStandardParameter (&lctxt, pvalue->u.nonStandardAddress);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iPAddress_network                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MulticastAddress_iPAddress_network (OOCTXT* pctxt, H245MulticastAddress_iPAddress_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iPAddress                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MulticastAddress_iPAddress (OOCTXT* pctxt, H245MulticastAddress_iPAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode network */
+
+   stat = asn1PE_H245MulticastAddress_iPAddress_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tsapIdentifier */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iP6Address_network                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MulticastAddress_iP6Address_network (OOCTXT* pctxt, H245MulticastAddress_iP6Address_network* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_iP6Address                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MulticastAddress_iP6Address (OOCTXT* pctxt, H245MulticastAddress_iP6Address* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode network */
+
+   stat = asn1PE_H245MulticastAddress_iP6Address_network (pctxt, &pvalue->network);
+   if (stat != ASN_OK) return stat;
+
+   /* encode tsapIdentifier */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress_nsap                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MulticastAddress_nsap (OOCTXT* pctxt, H245MulticastAddress_nsap* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MulticastAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MulticastAddress (OOCTXT* pctxt, H245MulticastAddress* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* iPAddress */
+         case 1:
+            stat = asn1PE_H245MulticastAddress_iPAddress (pctxt, pvalue->u.iPAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* iP6Address */
+         case 2:
+            stat = asn1PE_H245MulticastAddress_iP6Address (pctxt, pvalue->u.iP6Address);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* nsap */
+         case 3:
+            stat = asn1PE_H245MulticastAddress_nsap (&lctxt, pvalue->u.nsap);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* nonStandardAddress */
+         case 4:
+            stat = asn1PE_H245NonStandardParameter (&lctxt, pvalue->u.nonStandardAddress);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TransportAddress                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TransportAddress (OOCTXT* pctxt, H245TransportAddress* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* unicastAddress */
+         case 1:
+            stat = asn1PE_H245UnicastAddress (pctxt, pvalue->u.unicastAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* multicastAddress */
+         case 2:
+            stat = asn1PE_H245MulticastAddress (pctxt, pvalue->u.multicastAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  McuNumber                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245McuNumber (OOCTXT* pctxt, H245McuNumber value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 0U, 192U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalNumber                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalNumber (OOCTXT* pctxt, H245TerminalNumber value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 0U, 192U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalLabel                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalLabel (OOCTXT* pctxt, H245TerminalLabel* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode mcuNumber */
+
+   stat = asn1PE_H245McuNumber (pctxt, pvalue->mcuNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode terminalNumber */
+
+   stat = asn1PE_H245TerminalNumber (pctxt, pvalue->terminalNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelParameters_mediaPacketization          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H2250LogicalChannelParameters_mediaPacketization (OOCTXT* pctxt, H245H2250LogicalChannelParameters_mediaPacketization* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* h261aVideoPacketization */
+         case 1:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* rtpPayloadType */
+         case 2:
+            stat = asn1PE_H245RTPPayloadType (&lctxt, pvalue->u.rtpPayloadType);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelParameters                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H2250LogicalChannelParameters (OOCTXT* pctxt, H245H2250LogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.transportCapabilityPresent ||
+   pvalue->m.redundancyEncodingPresent ||
+   pvalue->m.sourcePresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.associatedSessionIDPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaChannelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaGuaranteedDeliveryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlChannelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlGuaranteedDeliveryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.silenceSuppressionPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.dynamicRTPPayloadTypePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaPacketizationPresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode sessionID */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sessionID, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode associatedSessionID */
+
+   if (pvalue->m.associatedSessionIDPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->associatedSessionID, 1U, 255U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode mediaChannel */
+
+   if (pvalue->m.mediaChannelPresent) {
+      stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaChannel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mediaGuaranteedDelivery */
+
+   if (pvalue->m.mediaGuaranteedDeliveryPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mediaGuaranteedDelivery);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mediaControlChannel */
+
+   if (pvalue->m.mediaControlChannelPresent) {
+      stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaControlChannel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mediaControlGuaranteedDelivery */
+
+   if (pvalue->m.mediaControlGuaranteedDeliveryPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mediaControlGuaranteedDelivery);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode silenceSuppression */
+
+   if (pvalue->m.silenceSuppressionPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->silenceSuppression);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode destination */
+
+   if (pvalue->m.destinationPresent) {
+      stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->destination);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode dynamicRTPPayloadType */
+
+   if (pvalue->m.dynamicRTPPayloadTypePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->dynamicRTPPayloadType, 96U, 127U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode mediaPacketization */
+
+   if (pvalue->m.mediaPacketizationPresent) {
+      stat = asn1PE_H245H2250LogicalChannelParameters_mediaPacketization (pctxt, &pvalue->mediaPacketization);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.redundancyEncodingPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourcePresent);
+      /* encode extension elements */
+
+      if (pvalue->m.transportCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245TransportCapability (&lctxt, &pvalue->transportCapability);
+         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.redundancyEncodingPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245RedundancyEncoding (&lctxt, &pvalue->redundancyEncoding);
+         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.sourcePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245TerminalLabel (&lctxt, &pvalue->source);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_forwardLogicalChannelParameters_multi  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* h222LogicalChannelParameters */
+         case 1:
+            stat = asn1PE_H245H222LogicalChannelParameters (pctxt, pvalue->u.h222LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h223LogicalChannelParameters */
+         case 2:
+            stat = asn1PE_H245H223LogicalChannelParameters (pctxt, pvalue->u.h223LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* v76LogicalChannelParameters */
+         case 3:
+            stat = asn1PE_H245V76LogicalChannelParameters (pctxt, pvalue->u.v76LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* h2250LogicalChannelParameters */
+         case 4:
+            stat = asn1PE_H245H2250LogicalChannelParameters (&lctxt, pvalue->u.h2250LogicalChannelParameters);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* none */
+         case 5:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_forwardLogicalChannelParameters        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.forwardLogicalChannelDependencyPresent ||
+   pvalue->m.replacementForPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.portNumberPresent);
+
+   /* encode portNumber */
+
+   if (pvalue->m.portNumberPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->portNumber, 0U, 65535U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode dataType */
+
+   stat = asn1PE_H245DataType (pctxt, &pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplexParameters */
+
+   stat = asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.forwardLogicalChannelDependencyPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.replacementForPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.forwardLogicalChannelDependencyPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->forwardLogicalChannelDependency);
+         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.replacementForPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->replacementFor);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_reverseLogicalChannelParameters_multi  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* h223LogicalChannelParameters */
+         case 1:
+            stat = asn1PE_H245H223LogicalChannelParameters (pctxt, pvalue->u.h223LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* v76LogicalChannelParameters */
+         case 2:
+            stat = asn1PE_H245V76LogicalChannelParameters (pctxt, pvalue->u.v76LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* h2250LogicalChannelParameters */
+         case 3:
+            stat = asn1PE_H245H2250LogicalChannelParameters (&lctxt, pvalue->u.h2250LogicalChannelParameters);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel_reverseLogicalChannelParameters        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.reverseLogicalChannelDependencyPresent ||
+   pvalue->m.replacementForPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.multiplexParametersPresent);
+
+   /* encode dataType */
+
+   stat = asn1PE_H245DataType (pctxt, &pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplexParameters */
+
+   if (pvalue->m.multiplexParametersPresent) {
+      stat = asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.reverseLogicalChannelDependencyPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.replacementForPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.reverseLogicalChannelDependencyPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->reverseLogicalChannelDependency);
+         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.replacementForPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->replacementFor);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_distribution                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NetworkAccessParameters_distribution (OOCTXT* pctxt, H245NetworkAccessParameters_distribution* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* unicast */
+         case 1:
+            /* NULL */
+            break;
+
+         /* multicast */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_networkAddress                    */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet;
+
+EXTERN int asn1PE_H245NetworkAccessParameters_networkAddress (OOCTXT* pctxt, H245NetworkAccessParameters_networkAddress* pvalue)
+{
+   static Asn1SizeCnst e164Address_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* q2931Address */
+         case 1:
+            stat = asn1PE_H245Q2931Address (pctxt, pvalue->u.q2931Address);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* e164Address */
+         case 2:
+            addSizeConstraint (pctxt, &e164Address_lsize1);
+
+            stat = encodeConstrainedStringEx (pctxt, pvalue->u.e164Address, gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet, 4, 4, 7);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* localAreaAddress */
+         case 3:
+            stat = asn1PE_H245TransportAddress (pctxt, pvalue->u.localAreaAddress);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_externalReference                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NetworkAccessParameters_externalReference (OOCTXT* pctxt, H245NetworkAccessParameters_externalReference* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 255, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters_t120SetupProcedure                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NetworkAccessParameters_t120SetupProcedure (OOCTXT* pctxt, H245NetworkAccessParameters_t120SetupProcedure* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* originateCall */
+         case 1:
+            /* NULL */
+            break;
+
+         /* waitForCall */
+         case 2:
+            /* NULL */
+            break;
+
+         /* issueQuery */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NetworkAccessParameters                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NetworkAccessParameters (OOCTXT* pctxt, H245NetworkAccessParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.t120SetupProcedurePresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.distributionPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.externalReferencePresent);
+
+   /* encode distribution */
+
+   if (pvalue->m.distributionPresent) {
+      stat = asn1PE_H245NetworkAccessParameters_distribution (pctxt, &pvalue->distribution);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode networkAddress */
+
+   stat = asn1PE_H245NetworkAccessParameters_networkAddress (pctxt, &pvalue->networkAddress);
+   if (stat != ASN_OK) return stat;
+
+   /* encode associateConference */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->associateConference);
+   if (stat != ASN_OK) return stat;
+
+   /* encode externalReference */
+
+   if (pvalue->m.externalReferencePresent) {
+      stat = asn1PE_H245NetworkAccessParameters_externalReference (pctxt, &pvalue->externalReference);
+      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.t120SetupProcedurePresent);
+      /* encode extension elements */
+
+      if (pvalue->m.t120SetupProcedurePresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245NetworkAccessParameters_t120SetupProcedure (&lctxt, &pvalue->t120SetupProcedure);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EscrowData_escrowValue                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EscrowData_escrowValue (OOCTXT* pctxt, H245EscrowData_escrowValue* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EscrowData                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EscrowData (OOCTXT* pctxt, H245EscrowData* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode escrowID */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->escrowID);
+   if (stat != ASN_OK) return stat;
+
+   /* encode escrowValue */
+
+   stat = asn1PE_H245EscrowData_escrowValue (pctxt, &pvalue->escrowValue);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionSync_escrowentry                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EncryptionSync_escrowentry (OOCTXT* pctxt, H245EncryptionSync_escrowentry* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245EscrowData (pctxt, ((H245EscrowData*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionSync                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EncryptionSync (OOCTXT* pctxt, H245EncryptionSync* pvalue)
+{
+   static Asn1SizeCnst h235Key_lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.escrowentryPresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode synchFlag */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->synchFlag, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h235Key */
+
+   addSizeConstraint (pctxt, &h235Key_lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->h235Key.numocts, pvalue->h235Key.data);
+   if (stat != ASN_OK) return stat;
+
+   /* encode escrowentry */
+
+   if (pvalue->m.escrowentryPresent) {
+      stat = asn1PE_H245EncryptionSync_escrowentry (pctxt, &pvalue->escrowentry);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannel                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannel (OOCTXT* pctxt, H245OpenLogicalChannel* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.separateStackPresent ||
+   pvalue->m.encryptionSyncPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.reverseLogicalChannelParametersPresent);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode forwardLogicalChannelParameters */
+
+   stat = asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters (pctxt, &pvalue->forwardLogicalChannelParameters);
+   if (stat != ASN_OK) return stat;
+
+   /* encode reverseLogicalChannelParameters */
+
+   if (pvalue->m.reverseLogicalChannelParametersPresent) {
+      stat = asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters (pctxt, &pvalue->reverseLogicalChannelParameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.separateStackPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.encryptionSyncPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.separateStackPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245NetworkAccessParameters (&lctxt, &pvalue->separateStack);
+         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.encryptionSyncPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245EncryptionSync (&lctxt, &pvalue->encryptionSync);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel_source                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CloseLogicalChannel_source (OOCTXT* pctxt, H245CloseLogicalChannel_source* 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)
+   {
+      /* user */
+      case 1:
+         /* NULL */
+         break;
+
+      /* lcse */
+      case 2:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel_reason                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CloseLogicalChannel_reason (OOCTXT* pctxt, H245CloseLogicalChannel_reason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unknown */
+         case 1:
+            /* NULL */
+            break;
+
+         /* reopen */
+         case 2:
+            /* NULL */
+            break;
+
+         /* reservationFailure */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannel                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CloseLogicalChannel (OOCTXT* pctxt, H245CloseLogicalChannel* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.reasonPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode source */
+
+   stat = asn1PE_H245CloseLogicalChannel_source (pctxt, &pvalue->source);
+   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.reasonPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.reasonPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245CloseLogicalChannel_reason (&lctxt, &pvalue->reason);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelClose_reason                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestChannelClose_reason (OOCTXT* pctxt, H245RequestChannelClose_reason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unknown */
+         case 1:
+            /* NULL */
+            break;
+
+         /* normal */
+         case 2:
+            /* NULL */
+            break;
+
+         /* reopen */
+         case 3:
+            /* NULL */
+            break;
+
+         /* reservationFailure */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelClose                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestChannelClose (OOCTXT* pctxt, H245RequestChannelClose* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.qosCapabilityPresent ||
+   pvalue->m.reasonPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.qosCapabilityPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.reasonPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.qosCapabilityPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245QOSCapability (&lctxt, &pvalue->qosCapability);
+         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.reasonPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245RequestChannelClose_reason (&lctxt, &pvalue->reason);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexTableEntryNumber                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexTableEntryNumber value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 1U, 15U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_type_subElementList                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexElement_type_subElementList (OOCTXT* pctxt, H245MultiplexElement_type_subElementList* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 2, 255, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245MultiplexElement (pctxt, (H245MultiplexElement*)((H245MultiplexElement*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_type                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexElement_type (OOCTXT* pctxt, H245MultiplexElement_type* 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)
+   {
+      /* logicalChannelNumber */
+      case 1:
+         stat = encodeConsUnsigned (pctxt, pvalue->u.logicalChannelNumber, 0U, 65535U);
+         if (stat != ASN_OK) return stat;
+
+         break;
+
+      /* subElementList */
+      case 2:
+         stat = asn1PE_H245MultiplexElement_type_subElementList (pctxt, pvalue->u.subElementList);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement_repeatCount                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexElement_repeatCount (OOCTXT* pctxt, H245MultiplexElement_repeatCount* 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)
+   {
+      /* finite */
+      case 1:
+         stat = encodeConsUnsigned (pctxt, pvalue->u.finite, 1U, 65535U);
+         if (stat != ASN_OK) return stat;
+
+         break;
+
+      /* untilClosingFlag */
+      case 2:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexElement                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexElement (OOCTXT* pctxt, H245MultiplexElement* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode type */
+
+   stat = asn1PE_H245MultiplexElement_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   /* encode repeatCount */
+
+   stat = asn1PE_H245MultiplexElement_repeatCount (pctxt, &pvalue->repeatCount);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryDescriptor_elementList                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntryDescriptor_elementList (OOCTXT* pctxt, H245MultiplexEntryDescriptor_elementList* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245MultiplexElement (pctxt, ((H245MultiplexElement*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryDescriptor                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntryDescriptor (OOCTXT* pctxt, H245MultiplexEntryDescriptor* pvalue)
+{
+   int stat = ASN_OK;
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.elementListPresent);
+
+   /* encode multiplexTableEntryNumber */
+
+   stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode elementList */
+
+   if (pvalue->m.elementListPresent) {
+      stat = asn1PE_H245MultiplexEntryDescriptor_elementList (pctxt, &pvalue->elementList);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySend_multiplexEntryDescriptors              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntrySend_multiplexEntryDescriptors (OOCTXT* pctxt, H245MultiplexEntrySend_multiplexEntryDescriptors* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245MultiplexEntryDescriptor (pctxt, ((H245MultiplexEntryDescriptor*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySend                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntrySend (OOCTXT* pctxt, H245MultiplexEntrySend* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplexEntryDescriptors */
+
+   stat = asn1PE_H245MultiplexEntrySend_multiplexEntryDescriptors (pctxt, &pvalue->multiplexEntryDescriptors);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntry_entryNumbers                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntry_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntry_entryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntry                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntry (OOCTXT* pctxt, H245RequestMultiplexEntry* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode entryNumbers */
+
+   stat = asn1PE_H245RequestMultiplexEntry_entryNumbers (pctxt, &pvalue->entryNumbers);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoMode_resolution                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H261VideoMode_resolution (OOCTXT* pctxt, H245H261VideoMode_resolution* 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)
+   {
+      /* qcif */
+      case 1:
+         /* NULL */
+         break;
+
+      /* cif */
+      case 2:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H261VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H261VideoMode (OOCTXT* pctxt, H245H261VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode resolution */
+
+   stat = asn1PE_H245H261VideoMode_resolution (pctxt, &pvalue->resolution);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 19200U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode stillImageTransmission */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->stillImageTransmission);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoMode_profileAndLevel                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H262VideoMode_profileAndLevel (OOCTXT* pctxt, H245H262VideoMode_profileAndLevel* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 11);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 10);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* profileAndLevel_SPatML */
+         case 1:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_MPatLL */
+         case 2:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_MPatML */
+         case 3:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_MPatH_14 */
+         case 4:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_MPatHL */
+         case 5:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_SNRatLL */
+         case 6:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_SNRatML */
+         case 7:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_SpatialatH_14 */
+         case 8:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_HPatML */
+         case 9:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_HPatH_14 */
+         case 10:
+            /* NULL */
+            break;
+
+         /* profileAndLevel_HPatHL */
+         case 11:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 12);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H262VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H262VideoMode (OOCTXT* pctxt, H245H262VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBitRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.vbvBufferSizePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.samplesPerLinePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.linesPerFramePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.framesPerSecondPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.luminanceSampleRatePresent);
+
+   /* encode profileAndLevel */
+
+   stat = asn1PE_H245H262VideoMode_profileAndLevel (pctxt, &pvalue->profileAndLevel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode videoBitRate */
+
+   if (pvalue->m.videoBitRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->videoBitRate, 0U, 1073741823U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode vbvBufferSize */
+
+   if (pvalue->m.vbvBufferSizePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->vbvBufferSize, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode samplesPerLine */
+
+   if (pvalue->m.samplesPerLinePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->samplesPerLine, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode linesPerFrame */
+
+   if (pvalue->m.linesPerFramePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->linesPerFrame, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode framesPerSecond */
+
+   if (pvalue->m.framesPerSecondPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->framesPerSecond, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode luminanceSampleRate */
+
+   if (pvalue->m.luminanceSampleRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoMode_resolution                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263VideoMode_resolution (OOCTXT* pctxt, H245H263VideoMode_resolution* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* sqcif */
+         case 1:
+            /* NULL */
+            break;
+
+         /* qcif */
+         case 2:
+            /* NULL */
+            break;
+
+         /* cif */
+         case 3:
+            /* NULL */
+            break;
+
+         /* cif4 */
+         case 4:
+            /* NULL */
+            break;
+
+         /* cif16 */
+         case 5:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* custom */
+         case 6:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H263VideoMode                                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H263VideoMode (OOCTXT* pctxt, H245H263VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.errorCompensationPresent ||
+   pvalue->m.enhancementLayerInfoPresent ||
+   pvalue->m.h263OptionsPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode resolution */
+
+   stat = asn1PE_H245H263VideoMode_resolution (pctxt, &pvalue->resolution);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 19200U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode unrestrictedVector */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unrestrictedVector);
+   if (stat != ASN_OK) return stat;
+
+   /* encode arithmeticCoding */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->arithmeticCoding);
+   if (stat != ASN_OK) return stat;
+
+   /* encode advancedPrediction */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedPrediction);
+   if (stat != ASN_OK) return stat;
+
+   /* encode pbFrames */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->pbFrames);
+   if (stat != ASN_OK) return stat;
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.errorCompensationPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.enhancementLayerInfoPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263OptionsPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.errorCompensationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->errorCompensation);
+         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.enhancementLayerInfoPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245EnhancementLayerInfo (&lctxt, &pvalue->enhancementLayerInfo);
+         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.h263OptionsPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245H263Options (&lctxt, &pvalue->h263Options);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172VideoMode                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS11172VideoMode (OOCTXT* pctxt, H245IS11172VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBitRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.vbvBufferSizePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.samplesPerLinePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.linesPerFramePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.pictureRatePresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.luminanceSampleRatePresent);
+
+   /* encode constrainedBitstream */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->constrainedBitstream);
+   if (stat != ASN_OK) return stat;
+
+   /* encode videoBitRate */
+
+   if (pvalue->m.videoBitRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->videoBitRate, 0U, 1073741823U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode vbvBufferSize */
+
+   if (pvalue->m.vbvBufferSizePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->vbvBufferSize, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode samplesPerLine */
+
+   if (pvalue->m.samplesPerLinePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->samplesPerLine, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode linesPerFrame */
+
+   if (pvalue->m.linesPerFramePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->linesPerFrame, 0U, 16383U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode pictureRate */
+
+   if (pvalue->m.pictureRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->pictureRate, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode luminanceSampleRate */
+
+   if (pvalue->m.luminanceSampleRatePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VideoMode                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VideoMode (OOCTXT* pctxt, H245VideoMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h261VideoMode */
+         case 2:
+            stat = asn1PE_H245H261VideoMode (pctxt, pvalue->u.h261VideoMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h262VideoMode */
+         case 3:
+            stat = asn1PE_H245H262VideoMode (pctxt, pvalue->u.h262VideoMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h263VideoMode */
+         case 4:
+            stat = asn1PE_H245H263VideoMode (pctxt, pvalue->u.h263VideoMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* is11172VideoMode */
+         case 5:
+            stat = asn1PE_H245IS11172VideoMode (pctxt, pvalue->u.is11172VideoMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* genericVideoMode */
+         case 6:
+            stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericVideoMode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioMode_g7231                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245AudioMode_g7231 (OOCTXT* pctxt, H245AudioMode_g7231* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* noSilenceSuppressionLowRate */
+      case 1:
+         /* NULL */
+         break;
+
+      /* noSilenceSuppressionHighRate */
+      case 2:
+         /* NULL */
+         break;
+
+      /* silenceSuppressionLowRate */
+      case 3:
+         /* NULL */
+         break;
+
+      /* silenceSuppressionHighRate */
+      case 4:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_audioLayer                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS11172AudioMode_audioLayer (OOCTXT* pctxt, H245IS11172AudioMode_audioLayer* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* audioLayer1 */
+      case 1:
+         /* NULL */
+         break;
+
+      /* audioLayer2 */
+      case 2:
+         /* NULL */
+         break;
+
+      /* audioLayer3 */
+      case 3:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_audioSampling                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS11172AudioMode_audioSampling (OOCTXT* pctxt, H245IS11172AudioMode_audioSampling* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* audioSampling32k */
+      case 1:
+         /* NULL */
+         break;
+
+      /* audioSampling44k1 */
+      case 2:
+         /* NULL */
+         break;
+
+      /* audioSampling48k */
+      case 3:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode_multichannelType                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS11172AudioMode_multichannelType (OOCTXT* pctxt, H245IS11172AudioMode_multichannelType* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* singleChannel */
+      case 1:
+         /* NULL */
+         break;
+
+      /* twoChannelStereo */
+      case 2:
+         /* NULL */
+         break;
+
+      /* twoChannelDual */
+      case 3:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS11172AudioMode                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS11172AudioMode (OOCTXT* pctxt, H245IS11172AudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode audioLayer */
+
+   stat = asn1PE_H245IS11172AudioMode_audioLayer (pctxt, &pvalue->audioLayer);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling */
+
+   stat = asn1PE_H245IS11172AudioMode_audioSampling (pctxt, &pvalue->audioSampling);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multichannelType */
+
+   stat = asn1PE_H245IS11172AudioMode_multichannelType (pctxt, &pvalue->multichannelType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 448U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_audioLayer                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS13818AudioMode_audioLayer (OOCTXT* pctxt, H245IS13818AudioMode_audioLayer* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* audioLayer1 */
+      case 1:
+         /* NULL */
+         break;
+
+      /* audioLayer2 */
+      case 2:
+         /* NULL */
+         break;
+
+      /* audioLayer3 */
+      case 3:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_audioSampling                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS13818AudioMode_audioSampling (OOCTXT* pctxt, H245IS13818AudioMode_audioSampling* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* audioSampling16k */
+      case 1:
+         /* NULL */
+         break;
+
+      /* audioSampling22k05 */
+      case 2:
+         /* NULL */
+         break;
+
+      /* audioSampling24k */
+      case 3:
+         /* NULL */
+         break;
+
+      /* audioSampling32k */
+      case 4:
+         /* NULL */
+         break;
+
+      /* audioSampling44k1 */
+      case 5:
+         /* NULL */
+         break;
+
+      /* audioSampling48k */
+      case 6:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode_multichannelType                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS13818AudioMode_multichannelType (OOCTXT* pctxt, H245IS13818AudioMode_multichannelType* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* singleChannel */
+      case 1:
+         /* NULL */
+         break;
+
+      /* twoChannelStereo */
+      case 2:
+         /* NULL */
+         break;
+
+      /* twoChannelDual */
+      case 3:
+         /* NULL */
+         break;
+
+      /* threeChannels2_1 */
+      case 4:
+         /* NULL */
+         break;
+
+      /* threeChannels3_0 */
+      case 5:
+         /* NULL */
+         break;
+
+      /* fourChannels2_0_2_0 */
+      case 6:
+         /* NULL */
+         break;
+
+      /* fourChannels2_2 */
+      case 7:
+         /* NULL */
+         break;
+
+      /* fourChannels3_1 */
+      case 8:
+         /* NULL */
+         break;
+
+      /* fiveChannels3_0_2_0 */
+      case 9:
+         /* NULL */
+         break;
+
+      /* fiveChannels3_2 */
+      case 10:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IS13818AudioMode                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IS13818AudioMode (OOCTXT* pctxt, H245IS13818AudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode audioLayer */
+
+   stat = asn1PE_H245IS13818AudioMode_audioLayer (pctxt, &pvalue->audioLayer);
+   if (stat != ASN_OK) return stat;
+
+   /* encode audioSampling */
+
+   stat = asn1PE_H245IS13818AudioMode_audioSampling (pctxt, &pvalue->audioSampling);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multichannelType */
+
+   stat = asn1PE_H245IS13818AudioMode_multichannelType (pctxt, &pvalue->multichannelType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode lowFrequencyEnhancement */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->lowFrequencyEnhancement);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multilingual */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multilingual);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 1130U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCMode_g723AnnexCAudioMode                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245G7231AnnexCMode_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCMode_g723AnnexCAudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode highRateMode0 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->highRateMode0, 27U, 78U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode highRateMode1 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->highRateMode1, 27U, 78U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode lowRateMode0 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->lowRateMode0, 23U, 66U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode lowRateMode1 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->lowRateMode1, 23U, 66U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sidMode0 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sidMode0, 6U, 17U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sidMode1 */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sidMode1, 6U, 17U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  G7231AnnexCMode                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245G7231AnnexCMode (OOCTXT* pctxt, H245G7231AnnexCMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode maxAl_sduAudioFrames */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxAl_sduAudioFrames, 1U, 256U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode silenceSuppression */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->silenceSuppression);
+   if (stat != ASN_OK) return stat;
+
+   /* encode g723AnnexCAudioMode */
+
+   stat = asn1PE_H245G7231AnnexCMode_g723AnnexCAudioMode (pctxt, &pvalue->g723AnnexCAudioMode);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VBDMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VBDMode (OOCTXT* pctxt, H245VBDMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = asn1PE_H245AudioMode (pctxt, (H245AudioMode*)pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  AudioMode                                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245AudioMode (OOCTXT* pctxt, H245AudioMode* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 14);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 13);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* g711Alaw64k */
+         case 2:
+            /* NULL */
+            break;
+
+         /* g711Alaw56k */
+         case 3:
+            /* NULL */
+            break;
+
+         /* g711Ulaw64k */
+         case 4:
+            /* NULL */
+            break;
+
+         /* g711Ulaw56k */
+         case 5:
+            /* NULL */
+            break;
+
+         /* g722_64k */
+         case 6:
+            /* NULL */
+            break;
+
+         /* g722_56k */
+         case 7:
+            /* NULL */
+            break;
+
+         /* g722_48k */
+         case 8:
+            /* NULL */
+            break;
+
+         /* g728 */
+         case 9:
+            /* NULL */
+            break;
+
+         /* g729 */
+         case 10:
+            /* NULL */
+            break;
+
+         /* g729AnnexA */
+         case 11:
+            /* NULL */
+            break;
+
+         /* g7231 */
+         case 12:
+            stat = asn1PE_H245AudioMode_g7231 (pctxt, pvalue->u.g7231);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* is11172AudioMode */
+         case 13:
+            stat = asn1PE_H245IS11172AudioMode (pctxt, pvalue->u.is11172AudioMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* is13818AudioMode */
+         case 14:
+            stat = asn1PE_H245IS13818AudioMode (pctxt, pvalue->u.is13818AudioMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 15);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* g729wAnnexB */
+         case 15:
+            stat = encodeConsUnsigned (&lctxt, pvalue->u.g729wAnnexB, 1U, 256U);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* g729AnnexAwAnnexB */
+         case 16:
+            stat = encodeConsUnsigned (&lctxt, pvalue->u.g729AnnexAwAnnexB, 1U, 256U);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* g7231AnnexCMode */
+         case 17:
+            stat = asn1PE_H245G7231AnnexCMode (&lctxt, pvalue->u.g7231AnnexCMode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* gsmFullRate */
+         case 18:
+            stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmFullRate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* gsmHalfRate */
+         case 19:
+            stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmHalfRate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* gsmEnhancedFullRate */
+         case 20:
+            stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmEnhancedFullRate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericAudioMode */
+         case 21:
+            stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericAudioMode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* g729Extensions */
+         case 22:
+            stat = asn1PE_H245G729Extensions (&lctxt, pvalue->u.g729Extensions);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* vbd */
+         case 23:
+            stat = asn1PE_H245VBDMode (&lctxt, pvalue->u.vbd);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application_nlpid                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataMode_application_nlpid (OOCTXT* pctxt, H245DataMode_application_nlpid* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode nlpidProtocol */
+
+   stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->nlpidProtocol);
+   if (stat != ASN_OK) return stat;
+
+   /* encode nlpidData */
+
+   stat = encodeOctetString (pctxt, pvalue->nlpidData.numocts, pvalue->nlpidData.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application_t38fax                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataMode_application_t38fax (OOCTXT* pctxt, H245DataMode_application_t38fax* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode t38FaxProtocol */
+
+   stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol);
+   if (stat != ASN_OK) return stat;
+
+   /* encode t38FaxProfile */
+
+   stat = asn1PE_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode_application                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataMode_application (OOCTXT* pctxt, H245DataMode_application* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 10);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* t120 */
+         case 2:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t120);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* dsm_cc */
+         case 3:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.dsm_cc);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* userData */
+         case 4:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.userData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* t84 */
+         case 5:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t84);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* t434 */
+         case 6:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t434);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h224 */
+         case 7:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.h224);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* nlpid */
+         case 8:
+            stat = asn1PE_H245DataMode_application_nlpid (pctxt, pvalue->u.nlpid);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* dsvdControl */
+         case 9:
+            /* NULL */
+            break;
+
+         /* h222DataPartitioning */
+         case 10:
+            stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.h222DataPartitioning);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* t30fax */
+         case 11:
+            stat = asn1PE_H245DataProtocolCapability (&lctxt, pvalue->u.t30fax);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* t140 */
+         case 12:
+            stat = asn1PE_H245DataProtocolCapability (&lctxt, pvalue->u.t140);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* t38fax */
+         case 13:
+            stat = asn1PE_H245DataMode_application_t38fax (&lctxt, pvalue->u.t38fax);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* genericDataMode */
+         case 14:
+            stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericDataMode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DataMode                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DataMode (OOCTXT* pctxt, H245DataMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode application */
+
+   stat = asn1PE_H245DataMode_application (pctxt, &pvalue->application);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235Mode_mediaMode                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H235Mode_mediaMode (OOCTXT* pctxt, H245H235Mode_mediaMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* videoMode */
+         case 2:
+            stat = asn1PE_H245VideoMode (pctxt, pvalue->u.videoMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* audioMode */
+         case 3:
+            stat = asn1PE_H245AudioMode (pctxt, pvalue->u.audioMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* dataMode */
+         case 4:
+            stat = asn1PE_H245DataMode (pctxt, pvalue->u.dataMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H235Mode                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H235Mode (OOCTXT* pctxt, H245H235Mode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode encryptionAuthenticationAndIntegrity */
+
+   stat = asn1PE_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mediaMode */
+
+   stat = asn1PE_H245H235Mode_mediaMode (pctxt, &pvalue->mediaMode);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTModeElement_type                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingDTModeElement_type (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* videoMode */
+         case 2:
+            stat = asn1PE_H245VideoMode (pctxt, pvalue->u.videoMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* audioMode */
+         case 3:
+            stat = asn1PE_H245AudioMode (pctxt, pvalue->u.audioMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* dataMode */
+         case 4:
+            stat = asn1PE_H245DataMode (pctxt, pvalue->u.dataMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* encryptionMode */
+         case 5:
+            stat = asn1PE_H245EncryptionMode (pctxt, pvalue->u.encryptionMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h235Mode */
+         case 6:
+            stat = asn1PE_H245H235Mode (pctxt, pvalue->u.h235Mode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTModeElement                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = asn1PE_H245RedundancyEncodingDTModeElement_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245RedundancyEncodingDTModeElement                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingDTModeElement* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245RedundancyEncodingDTModeElement (pctxt, ((H245RedundancyEncodingDTModeElement*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingDTMode                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingDTMode (OOCTXT* pctxt, H245RedundancyEncodingDTMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode redundancyEncodingMethod */
+
+   stat = asn1PE_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod);
+   if (stat != ASN_OK) return stat;
+
+   /* encode primary */
+
+   stat = asn1PE_H245RedundancyEncodingDTModeElement (pctxt, &pvalue->primary);
+   if (stat != ASN_OK) return stat;
+
+   /* encode secondary */
+
+   stat = asn1PE_H245_SeqOfH245RedundancyEncodingDTModeElement (pctxt, &pvalue->secondary);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamElementMode                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245MultiplePayloadStreamElementMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = asn1PE_H245ModeElementType (pctxt, (H245ModeElementType*)pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245MultiplePayloadStreamElementMode                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElementMode* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245MultiplePayloadStreamElementMode (pctxt, ((H245MultiplePayloadStreamElementMode*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplePayloadStreamMode                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplePayloadStreamMode (OOCTXT* pctxt, H245MultiplePayloadStreamMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode elements */
+
+   stat = asn1PE_H245_SeqOfH245MultiplePayloadStreamElementMode (pctxt, &pvalue->elements);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream_differentPort     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.protectedPayloadTypePresent);
+
+   /* encode protectedSessionID */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->protectedSessionID, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode protectedPayloadType */
+
+   if (pvalue->m.protectedPayloadTypePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->protectedPayloadType, 0U, 127U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream_samePort          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_samePort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode protectedType */
+
+   stat = asn1PE_H245ModeElementType (pctxt, (H245ModeElementType*)pvalue->protectedType);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode_separateStream                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* differentPort */
+         case 1:
+            stat = asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (pctxt, pvalue->u.differentPort);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* samePort */
+         case 2:
+            stat = asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_samePort (pctxt, pvalue->u.samePort);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode_mode                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* redundancyEncoding */
+         case 1:
+            /* NULL */
+            break;
+
+         /* separateStream */
+         case 2:
+            stat = asn1PE_H245FECMode_rfc2733Mode_mode_separateStream (pctxt, pvalue->u.separateStream);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode_rfc2733Mode                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECMode_rfc2733Mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode mode */
+
+   stat = asn1PE_H245FECMode_rfc2733Mode_mode (pctxt, &pvalue->mode);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FECMode                                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FECMode (OOCTXT* pctxt, H245FECMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* rfc2733Mode */
+         case 1:
+            stat = asn1PE_H245FECMode_rfc2733Mode (pctxt, pvalue->u.rfc2733Mode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ModeElementType                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ModeElementType (OOCTXT* pctxt, H245ModeElementType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* videoMode */
+         case 2:
+            stat = asn1PE_H245VideoMode (pctxt, pvalue->u.videoMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* audioMode */
+         case 3:
+            stat = asn1PE_H245AudioMode (pctxt, pvalue->u.audioMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* dataMode */
+         case 4:
+            stat = asn1PE_H245DataMode (pctxt, pvalue->u.dataMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* encryptionMode */
+         case 5:
+            stat = asn1PE_H245EncryptionMode (pctxt, pvalue->u.encryptionMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* h235Mode */
+         case 6:
+            stat = asn1PE_H245H235Mode (&lctxt, pvalue->u.h235Mode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multiplexedStreamMode */
+         case 7:
+            stat = asn1PE_H245MultiplexedStreamParameter (&lctxt, pvalue->u.multiplexedStreamMode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* redundancyEncodingDTMode */
+         case 8:
+            stat = asn1PE_H245RedundancyEncodingDTMode (&lctxt, pvalue->u.redundancyEncodingDTMode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multiplePayloadStreamMode */
+         case 9:
+            stat = asn1PE_H245MultiplePayloadStreamMode (&lctxt, pvalue->u.multiplePayloadStreamMode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* fecMode */
+         case 10:
+            stat = asn1PE_H245FECMode (&lctxt, pvalue->u.fecMode);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters_adaptationLayerType_al3                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223ModeParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType_al3* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode controlFieldOctets */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->controlFieldOctets, 0U, 2U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sendBufferSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sendBufferSize, 0U, 16777215U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters_adaptationLayerType                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223ModeParameters_adaptationLayerType (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* al1Framed */
+         case 2:
+            /* NULL */
+            break;
+
+         /* al1NotFramed */
+         case 3:
+            /* NULL */
+            break;
+
+         /* al2WithoutSequenceNumbers */
+         case 4:
+            /* NULL */
+            break;
+
+         /* al2WithSequenceNumbers */
+         case 5:
+            /* NULL */
+            break;
+
+         /* al3 */
+         case 6:
+            stat = asn1PE_H245H223ModeParameters_adaptationLayerType_al3 (pctxt, pvalue->u.al3);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* al1M */
+         case 7:
+            stat = asn1PE_H245H223AL1MParameters (&lctxt, pvalue->u.al1M);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* al2M */
+         case 8:
+            stat = asn1PE_H245H223AL2MParameters (&lctxt, pvalue->u.al2M);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* al3M */
+         case 9:
+            stat = asn1PE_H245H223AL3MParameters (&lctxt, pvalue->u.al3M);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223ModeParameters                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223ModeParameters (OOCTXT* pctxt, H245H223ModeParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode adaptationLayerType */
+
+   stat = asn1PE_H245H223ModeParameters_adaptationLayerType (pctxt, &pvalue->adaptationLayerType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode segmentableFlag */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->segmentableFlag);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  V76ModeParameters                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245V76ModeParameters (OOCTXT* pctxt, H245V76ModeParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* suspendResumewAddress */
+         case 1:
+            /* NULL */
+            break;
+
+         /* suspendResumewoAddress */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMode_secondaryEncoding                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingMode_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingMode_secondaryEncoding* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* audioData */
+         case 2:
+            stat = asn1PE_H245AudioMode (pctxt, pvalue->u.audioData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RedundancyEncodingMode                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RedundancyEncodingMode (OOCTXT* pctxt, H245RedundancyEncodingMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.secondaryEncodingPresent);
+
+   /* encode redundancyEncodingMethod */
+
+   stat = asn1PE_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod);
+   if (stat != ASN_OK) return stat;
+
+   /* encode secondaryEncoding */
+
+   if (pvalue->m.secondaryEncodingPresent) {
+      stat = asn1PE_H245RedundancyEncodingMode_secondaryEncoding (pctxt, &pvalue->secondaryEncoding);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250ModeParameters                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H2250ModeParameters (OOCTXT* pctxt, H245H2250ModeParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.redundancyEncodingModePresent);
+
+   /* encode redundancyEncodingMode */
+
+   if (pvalue->m.redundancyEncodingModePresent) {
+      stat = asn1PE_H245RedundancyEncodingMode (pctxt, &pvalue->redundancyEncodingMode);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexedStreamModeParameters                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexedStreamModeParameters (OOCTXT* pctxt, H245MultiplexedStreamModeParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode logicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ModeElement                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ModeElement (OOCTXT* pctxt, H245ModeElement* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.v76ModeParametersPresent ||
+   pvalue->m.h2250ModeParametersPresent ||
+   pvalue->m.genericModeParametersPresent ||
+   pvalue->m.multiplexedStreamModeParametersPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.h223ModeParametersPresent);
+
+   /* encode type */
+
+   stat = asn1PE_H245ModeElementType (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   /* encode h223ModeParameters */
+
+   if (pvalue->m.h223ModeParametersPresent) {
+      stat = asn1PE_H245H223ModeParameters (pctxt, &pvalue->h223ModeParameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.v76ModeParametersPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h2250ModeParametersPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericModeParametersPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.multiplexedStreamModeParametersPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.v76ModeParametersPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245V76ModeParameters (&lctxt, &pvalue->v76ModeParameters);
+         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.h2250ModeParametersPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245H2250ModeParameters (&lctxt, &pvalue->h2250ModeParameters);
+         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.genericModeParametersPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245GenericCapability (&lctxt, &pvalue->genericModeParameters);
+         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.multiplexedStreamModeParametersPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245MultiplexedStreamModeParameters (&lctxt, &pvalue->multiplexedStreamModeParameters);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ModeDescription                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ModeDescription (OOCTXT* pctxt, H245ModeDescription* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245ModeElement (pctxt, ((H245ModeElement*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMode_requestedModes                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMode_requestedModes (OOCTXT* pctxt, H245RequestMode_requestedModes* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245ModeDescription (pctxt, ((H245ModeDescription*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMode                                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMode (OOCTXT* pctxt, H245RequestMode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode requestedModes */
+
+   stat = asn1PE_H245RequestMode_requestedModes (pctxt, &pvalue->requestedModes);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RoundTripDelayRequest                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RoundTripDelayRequest (OOCTXT* pctxt, H245RoundTripDelayRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopRequest_type                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaintenanceLoopRequest_type (OOCTXT* pctxt, H245MaintenanceLoopRequest_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* systemLoop */
+         case 1:
+            /* NULL */
+            break;
+
+         /* mediaLoop */
+         case 2:
+            stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.mediaLoop);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* logicalChannelLoop */
+         case 3:
+            stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelLoop);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopRequest                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaintenanceLoopRequest (OOCTXT* pctxt, H245MaintenanceLoopRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = asn1PE_H245MaintenanceLoopRequest_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeRequest                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CommunicationModeRequest (OOCTXT* pctxt, H245CommunicationModeRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Criteria                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245Criteria (OOCTXT* pctxt, H245Criteria* pvalue)
+{
+   static Asn1SizeCnst value_lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode field */
+
+   stat = encodeObjectIdentifier (pctxt, &pvalue->field);
+   if (stat != ASN_OK) return stat;
+
+   /* encode value */
+
+   addSizeConstraint (pctxt, &value_lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->value.numocts, pvalue->value.data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CertSelectionCriteria                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CertSelectionCriteria (OOCTXT* pctxt, H245CertSelectionCriteria* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245Criteria (pctxt, ((H245Criteria*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceRequest_requestTerminalCertificate              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceRequest_requestTerminalCertificate (OOCTXT* pctxt, H245ConferenceRequest_requestTerminalCertificate* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalLabelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.certSelectionCriteriaPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sRandomPresent);
+
+   /* encode terminalLabel */
+
+   if (pvalue->m.terminalLabelPresent) {
+      stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode certSelectionCriteria */
+
+   if (pvalue->m.certSelectionCriteriaPresent) {
+      stat = asn1PE_H245CertSelectionCriteria (pctxt, &pvalue->certSelectionCriteria);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode sRandom */
+
+   if (pvalue->m.sRandomPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->sRandom, 1U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCRequest                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RemoteMCRequest (OOCTXT* pctxt, H245RemoteMCRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* masterActivate */
+         case 1:
+            /* NULL */
+            break;
+
+         /* slaveActivate */
+         case 2:
+            /* NULL */
+            break;
+
+         /* deActivate */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceRequest                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceRequest (OOCTXT* pctxt, H245ConferenceRequest* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 8);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* terminalListRequest */
+         case 1:
+            /* NULL */
+            break;
+
+         /* makeMeChair */
+         case 2:
+            /* NULL */
+            break;
+
+         /* cancelMakeMeChair */
+         case 3:
+            /* NULL */
+            break;
+
+         /* dropTerminal */
+         case 4:
+            stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.dropTerminal);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestTerminalID */
+         case 5:
+            stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.requestTerminalID);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* enterH243Password */
+         case 6:
+            /* NULL */
+            break;
+
+         /* enterH243TerminalID */
+         case 7:
+            /* NULL */
+            break;
+
+         /* enterH243ConferenceID */
+         case 8:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* enterExtensionAddress */
+         case 9:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* requestChairTokenOwner */
+         case 10:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* requestTerminalCertificate */
+         case 11:
+            stat = asn1PE_H245ConferenceRequest_requestTerminalCertificate (&lctxt, pvalue->u.requestTerminalCertificate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* broadcastMyLogicalChannel */
+         case 12:
+            stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->u.broadcastMyLogicalChannel);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* makeTerminalBroadcaster */
+         case 13:
+            stat = asn1PE_H245TerminalLabel (&lctxt, pvalue->u.makeTerminalBroadcaster);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* sendThisSource */
+         case 14:
+            stat = asn1PE_H245TerminalLabel (&lctxt, pvalue->u.sendThisSource);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* requestAllTerminalIDs */
+         case 15:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* remoteMCRequest */
+         case 16:
+            stat = asn1PE_H245RemoteMCRequest (&lctxt, pvalue->u.remoteMCRequest);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_callInformation                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkRequest_callInformation (OOCTXT* pctxt, H245MultilinkRequest_callInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode maxNumberOfAdditionalConnections */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maxNumberOfAdditionalConnections, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNetworkType                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DialingInformationNetworkType (OOCTXT* pctxt, H245DialingInformationNetworkType* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* n_isdn */
+         case 2:
+            /* NULL */
+            break;
+
+         /* gstn */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* mobile */
+         case 4:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNumber_networkType                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DialingInformationNumber_networkType (OOCTXT* pctxt, H245DialingInformationNumber_networkType* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 255, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245DialingInformationNetworkType (pctxt, ((H245DialingInformationNetworkType*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformationNumber                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DialingInformationNumber (OOCTXT* pctxt, H245DialingInformationNumber* pvalue)
+{
+   static Asn1SizeCnst networkAddress_lsize1 = { 0, 0, 40, 0 };
+   static Asn1SizeCnst subAddress_lsize1 = { 0, 1, 40, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.subAddressPresent);
+
+   /* encode networkAddress */
+
+   addSizeConstraint (pctxt, &networkAddress_lsize1);
+
+   stat = encodeConstrainedStringEx (pctxt, pvalue->networkAddress, NUM_CANSET, 4, 4, 4);
+   if (stat != ASN_OK) return stat;
+
+   /* encode subAddress */
+
+   if (pvalue->m.subAddressPresent) {
+      addSizeConstraint (pctxt, &subAddress_lsize1);
+
+      stat = encodeConstrainedStringEx (pctxt, pvalue->subAddress, 0, 8, 7, 7);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode networkType */
+
+   stat = asn1PE_H245DialingInformationNumber_networkType (pctxt, &pvalue->networkType);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformation_differential                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DialingInformation_differential (OOCTXT* pctxt, H245DialingInformation_differential* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245DialingInformationNumber (pctxt, ((H245DialingInformationNumber*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  DialingInformation                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245DialingInformation (OOCTXT* pctxt, H245DialingInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* differential */
+         case 2:
+            stat = asn1PE_H245DialingInformation_differential (pctxt, pvalue->u.differential);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* infoNotAvailable */
+         case 3:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.infoNotAvailable, 1U, 65535U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_addConnection                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkRequest_addConnection (OOCTXT* pctxt, H245MultilinkRequest_addConnection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dialingInformation */
+
+   stat = asn1PE_H245DialingInformation (pctxt, &pvalue->dialingInformation);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConnectionIdentifier                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConnectionIdentifier (OOCTXT* pctxt, H245ConnectionIdentifier* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode channelTag */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->channelTag, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sequenceNumber */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sequenceNumber, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_removeConnection                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkRequest_removeConnection (OOCTXT* pctxt, H245MultilinkRequest_removeConnection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode connectionIdentifier */
+
+   stat = asn1PE_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_maximumHeaderInterval_requestType        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkRequest_maximumHeaderInterval_requestType (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval_requestType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* currentIntervalInformation */
+         case 1:
+            /* NULL */
+            break;
+
+         /* requestedInterval */
+         case 2:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.requestedInterval, 0U, 65535U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest_maximumHeaderInterval                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkRequest_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode requestType */
+
+   stat = asn1PE_H245MultilinkRequest_maximumHeaderInterval_requestType (pctxt, &pvalue->requestType);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkRequest                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkRequest (OOCTXT* pctxt, H245MultilinkRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* callInformation */
+         case 2:
+            stat = asn1PE_H245MultilinkRequest_callInformation (pctxt, pvalue->u.callInformation);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* addConnection */
+         case 3:
+            stat = asn1PE_H245MultilinkRequest_addConnection (pctxt, pvalue->u.addConnection);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* removeConnection */
+         case 4:
+            stat = asn1PE_H245MultilinkRequest_removeConnection (pctxt, pvalue->u.removeConnection);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* maximumHeaderInterval */
+         case 5:
+            stat = asn1PE_H245MultilinkRequest_maximumHeaderInterval (pctxt, pvalue->u.maximumHeaderInterval);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaximumBitRate                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaximumBitRate (OOCTXT* pctxt, H245MaximumBitRate value)
+{
+   int stat = ASN_OK;
+
+   stat = encodeConsUnsigned (pctxt, value, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRequest                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245LogicalChannelRateRequest (OOCTXT* pctxt, H245LogicalChannelRateRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode logicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maximumBitRate */
+
+   stat = asn1PE_H245MaximumBitRate (pctxt, pvalue->maximumBitRate);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMessage                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMessage (OOCTXT* pctxt, H245RequestMessage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 11);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 10);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* masterSlaveDetermination */
+         case 2:
+            stat = asn1PE_H245MasterSlaveDetermination (pctxt, pvalue->u.masterSlaveDetermination);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* terminalCapabilitySet */
+         case 3:
+            stat = asn1PE_H245TerminalCapabilitySet (pctxt, pvalue->u.terminalCapabilitySet);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* openLogicalChannel */
+         case 4:
+            stat = asn1PE_H245OpenLogicalChannel (pctxt, pvalue->u.openLogicalChannel);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* closeLogicalChannel */
+         case 5:
+            stat = asn1PE_H245CloseLogicalChannel (pctxt, pvalue->u.closeLogicalChannel);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestChannelClose */
+         case 6:
+            stat = asn1PE_H245RequestChannelClose (pctxt, pvalue->u.requestChannelClose);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* multiplexEntrySend */
+         case 7:
+            stat = asn1PE_H245MultiplexEntrySend (pctxt, pvalue->u.multiplexEntrySend);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestMultiplexEntry */
+         case 8:
+            stat = asn1PE_H245RequestMultiplexEntry (pctxt, pvalue->u.requestMultiplexEntry);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestMode */
+         case 9:
+            stat = asn1PE_H245RequestMode (pctxt, pvalue->u.requestMode);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* roundTripDelayRequest */
+         case 10:
+            stat = asn1PE_H245RoundTripDelayRequest (pctxt, pvalue->u.roundTripDelayRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* maintenanceLoopRequest */
+         case 11:
+            stat = asn1PE_H245MaintenanceLoopRequest (pctxt, pvalue->u.maintenanceLoopRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 12);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* communicationModeRequest */
+         case 12:
+            stat = asn1PE_H245CommunicationModeRequest (&lctxt, pvalue->u.communicationModeRequest);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* conferenceRequest */
+         case 13:
+            stat = asn1PE_H245ConferenceRequest (&lctxt, pvalue->u.conferenceRequest);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multilinkRequest */
+         case 14:
+            stat = asn1PE_H245MultilinkRequest (&lctxt, pvalue->u.multilinkRequest);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* logicalChannelRateRequest */
+         case 15:
+            stat = asn1PE_H245LogicalChannelRateRequest (&lctxt, pvalue->u.logicalChannelRateRequest);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationAck_decision                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationAck_decision (OOCTXT* pctxt, H245MasterSlaveDeterminationAck_decision* 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)
+   {
+      /* master */
+      case 1:
+         /* NULL */
+         break;
+
+      /* slave */
+      case 2:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationAck                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationAck (OOCTXT* pctxt, H245MasterSlaveDeterminationAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode decision */
+
+   stat = asn1PE_H245MasterSlaveDeterminationAck_decision (pctxt, &pvalue->decision);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationReject_cause                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationReject_cause (OOCTXT* pctxt, H245MasterSlaveDeterminationReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* identicalNumbers */
+         case 1:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationReject                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationReject (OOCTXT* pctxt, H245MasterSlaveDeterminationReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode cause */
+
+   stat = asn1PE_H245MasterSlaveDeterminationReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetAck                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalCapabilitySetAck (OOCTXT* pctxt, H245TerminalCapabilitySetAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject_cause_tableEntryCapacityExce  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded* 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)
+   {
+      /* highestEntryNumberProcessed */
+      case 1:
+         stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->u.highestEntryNumberProcessed);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      /* noneProcessed */
+      case 2:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject_cause                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalCapabilitySetReject_cause (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unspecified */
+         case 1:
+            /* NULL */
+            break;
+
+         /* undefinedTableEntryUsed */
+         case 2:
+            /* NULL */
+            break;
+
+         /* descriptorCapacityExceeded */
+         case 3:
+            /* NULL */
+            break;
+
+         /* tableEntryCapacityExceeded */
+         case 4:
+            stat = asn1PE_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (pctxt, pvalue->u.tableEntryCapacityExceeded);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetReject                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalCapabilitySetReject (OOCTXT* pctxt, H245TerminalCapabilitySetReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cause */
+
+   stat = asn1PE_H245TerminalCapabilitySetReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_reverseLogicalChannelParameters_mu  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* h222LogicalChannelParameters */
+         case 1:
+            stat = asn1PE_H245H222LogicalChannelParameters (pctxt, pvalue->u.h222LogicalChannelParameters);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* h2250LogicalChannelParameters */
+         case 2:
+            stat = asn1PE_H245H2250LogicalChannelParameters (&lctxt, pvalue->u.h2250LogicalChannelParameters);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_reverseLogicalChannelParameters     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.replacementForPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.portNumberPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.multiplexParametersPresent);
+
+   /* encode reverseLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->reverseLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode portNumber */
+
+   if (pvalue->m.portNumberPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->portNumber, 0U, 65535U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode multiplexParameters */
+
+   if (pvalue->m.multiplexParametersPresent) {
+      stat = asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters);
+      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.replacementForPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.replacementForPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->replacementFor);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250LogicalChannelAckParameters                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H2250LogicalChannelAckParameters (OOCTXT* pctxt, H245H2250LogicalChannelAckParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.flowControlToZeroPresent ||
+   pvalue->m.portNumberPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.sessionIDPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaChannelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlChannelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.dynamicRTPPayloadTypePresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode sessionID */
+
+   if (pvalue->m.sessionIDPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->sessionID, 1U, 255U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode mediaChannel */
+
+   if (pvalue->m.mediaChannelPresent) {
+      stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaChannel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mediaControlChannel */
+
+   if (pvalue->m.mediaControlChannelPresent) {
+      stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaControlChannel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode dynamicRTPPayloadType */
+
+   if (pvalue->m.dynamicRTPPayloadTypePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->dynamicRTPPayloadType, 96U, 127U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 1);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.flowControlToZeroPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.portNumberPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.flowControlToZeroPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->flowControlToZero);
+         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.portNumberPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->portNumber, 0U, 65535U);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck_forwardMultiplexAckParameters       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_forwardMultiplexAckParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* h2250LogicalChannelAckParameters */
+         case 1:
+            stat = asn1PE_H245H2250LogicalChannelAckParameters (pctxt, pvalue->u.h2250LogicalChannelAckParameters);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelAck                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannelAck (OOCTXT* pctxt, H245OpenLogicalChannelAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.separateStackPresent ||
+   pvalue->m.forwardMultiplexAckParametersPresent ||
+   pvalue->m.encryptionSyncPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.reverseLogicalChannelParametersPresent);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode reverseLogicalChannelParameters */
+
+   if (pvalue->m.reverseLogicalChannelParametersPresent) {
+      stat = asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (pctxt, &pvalue->reverseLogicalChannelParameters);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.separateStackPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.forwardMultiplexAckParametersPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.encryptionSyncPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.separateStackPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245NetworkAccessParameters (&lctxt, &pvalue->separateStack);
+         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.forwardMultiplexAckParametersPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (&lctxt, &pvalue->forwardMultiplexAckParameters);
+         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.encryptionSyncPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245EncryptionSync (&lctxt, &pvalue->encryptionSync);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelReject_cause                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannelReject_cause (OOCTXT* pctxt, H245OpenLogicalChannelReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 6);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unspecified */
+         case 1:
+            /* NULL */
+            break;
+
+         /* unsuitableReverseParameters */
+         case 2:
+            /* NULL */
+            break;
+
+         /* dataTypeNotSupported */
+         case 3:
+            /* NULL */
+            break;
+
+         /* dataTypeNotAvailable */
+         case 4:
+            /* NULL */
+            break;
+
+         /* unknownDataType */
+         case 5:
+            /* NULL */
+            break;
+
+         /* dataTypeALCombinationNotSupported */
+         case 6:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* multicastChannelNotAllowed */
+         case 7:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* insufficientBandwidth */
+         case 8:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* separateStackEstablishmentFailed */
+         case 9:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* invalidSessionID */
+         case 10:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* masterSlaveConflict */
+         case 11:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* waitForCommunicationMode */
+         case 12:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* invalidDependentChannel */
+         case 13:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* replacementForRejected */
+         case 14:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelReject                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannelReject (OOCTXT* pctxt, H245OpenLogicalChannelReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cause */
+
+   stat = asn1PE_H245OpenLogicalChannelReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CloseLogicalChannelAck                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CloseLogicalChannelAck (OOCTXT* pctxt, H245CloseLogicalChannelAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseAck                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestChannelCloseAck (OOCTXT* pctxt, H245RequestChannelCloseAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseReject_cause                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestChannelCloseReject_cause (OOCTXT* pctxt, H245RequestChannelCloseReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unspecified */
+         case 1:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseReject                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestChannelCloseReject (OOCTXT* pctxt, H245RequestChannelCloseReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cause */
+
+   stat = asn1PE_H245RequestChannelCloseReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendAck_multiplexTableEntryNumber           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntrySendAck_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendAck_multiplexTableEntryNumber* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendAck                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntrySendAck (OOCTXT* pctxt, H245MultiplexEntrySendAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplexTableEntryNumber */
+
+   stat = asn1PE_H245MultiplexEntrySendAck_multiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryRejectionDescriptions_cause                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* unspecifiedCause */
+         case 1:
+            /* NULL */
+            break;
+
+         /* descriptorTooComplex */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntryRejectionDescriptions                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode multiplexTableEntryNumber */
+
+   stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cause */
+
+   stat = asn1PE_H245MultiplexEntryRejectionDescriptions_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendReject_rejectionDescriptions            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntrySendReject_rejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntrySendReject_rejectionDescriptions* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245MultiplexEntryRejectionDescriptions (pctxt, ((H245MultiplexEntryRejectionDescriptions*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendReject                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntrySendReject (OOCTXT* pctxt, H245MultiplexEntrySendReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejectionDescriptions */
+
+   stat = asn1PE_H245MultiplexEntrySendReject_rejectionDescriptions (pctxt, &pvalue->rejectionDescriptions);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryAck_entryNumbers                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryAck_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryAck_entryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryAck                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryAck (OOCTXT* pctxt, H245RequestMultiplexEntryAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode entryNumbers */
+
+   stat = asn1PE_H245RequestMultiplexEntryAck_entryNumbers (pctxt, &pvalue->entryNumbers);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject_entryNumbers                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryReject_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryReject_entryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRejectionDescriptions_cause          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* unspecifiedCause */
+         case 1:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRejectionDescriptions                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode multiplexTableEntryNumber */
+
+   stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cause */
+
+   stat = asn1PE_H245RequestMultiplexEntryRejectionDescriptions_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject_rejectionDescriptions         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryReject_rejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryReject_rejectionDescriptions* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245RequestMultiplexEntryRejectionDescriptions (pctxt, ((H245RequestMultiplexEntryRejectionDescriptions*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryReject                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryReject (OOCTXT* pctxt, H245RequestMultiplexEntryReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode entryNumbers */
+
+   stat = asn1PE_H245RequestMultiplexEntryReject_entryNumbers (pctxt, &pvalue->entryNumbers);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejectionDescriptions */
+
+   stat = asn1PE_H245RequestMultiplexEntryReject_rejectionDescriptions (pctxt, &pvalue->rejectionDescriptions);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeAck_response                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestModeAck_response (OOCTXT* pctxt, H245RequestModeAck_response* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* willTransmitMostPreferredMode */
+         case 1:
+            /* NULL */
+            break;
+
+         /* willTransmitLessPreferredMode */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeAck                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestModeAck (OOCTXT* pctxt, H245RequestModeAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode response */
+
+   stat = asn1PE_H245RequestModeAck_response (pctxt, &pvalue->response);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeReject_cause                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestModeReject_cause (OOCTXT* pctxt, H245RequestModeReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* modeUnavailable */
+         case 1:
+            /* NULL */
+            break;
+
+         /* multipointConstraint */
+         case 2:
+            /* NULL */
+            break;
+
+         /* requestDenied */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeReject                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestModeReject (OOCTXT* pctxt, H245RequestModeReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cause */
+
+   stat = asn1PE_H245RequestModeReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RoundTripDelayResponse                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RoundTripDelayResponse (OOCTXT* pctxt, H245RoundTripDelayResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopAck_type                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaintenanceLoopAck_type (OOCTXT* pctxt, H245MaintenanceLoopAck_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* systemLoop */
+         case 1:
+            /* NULL */
+            break;
+
+         /* mediaLoop */
+         case 2:
+            stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.mediaLoop);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* logicalChannelLoop */
+         case 3:
+            stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelLoop);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopAck                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaintenanceLoopAck (OOCTXT* pctxt, H245MaintenanceLoopAck* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = asn1PE_H245MaintenanceLoopAck_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject_type                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaintenanceLoopReject_type (OOCTXT* pctxt, H245MaintenanceLoopReject_type* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* systemLoop */
+         case 1:
+            /* NULL */
+            break;
+
+         /* mediaLoop */
+         case 2:
+            stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.mediaLoop);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* logicalChannelLoop */
+         case 3:
+            stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelLoop);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject_cause                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaintenanceLoopReject_cause (OOCTXT* pctxt, H245MaintenanceLoopReject_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* canNotPerformLoop */
+         case 1:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopReject                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaintenanceLoopReject (OOCTXT* pctxt, H245MaintenanceLoopReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode type */
+
+   stat = asn1PE_H245MaintenanceLoopReject_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   /* encode cause */
+
+   stat = asn1PE_H245MaintenanceLoopReject_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeTableEntry_dataType                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CommunicationModeTableEntry_dataType (OOCTXT* pctxt, H245CommunicationModeTableEntry_dataType* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* videoData */
+         case 1:
+            stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.videoData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* audioData */
+         case 2:
+            stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.audioData);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* data */
+         case 3:
+            stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.data);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeTableEntry                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CommunicationModeTableEntry (OOCTXT* pctxt, H245CommunicationModeTableEntry* pvalue)
+{
+   static Asn1SizeCnst sessionDescription_lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.redundancyEncodingPresent ||
+   pvalue->m.sessionDependencyPresent ||
+   pvalue->m.destinationPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.associatedSessionIDPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalLabelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaChannelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaGuaranteedDeliveryPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlChannelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlGuaranteedDeliveryPresent);
+
+   /* encode nonStandard */
+
+   if (pvalue->m.nonStandardPresent) {
+      stat = asn1PE_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode sessionID */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sessionID, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode associatedSessionID */
+
+   if (pvalue->m.associatedSessionIDPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->associatedSessionID, 1U, 255U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode terminalLabel */
+
+   if (pvalue->m.terminalLabelPresent) {
+      stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode sessionDescription */
+
+   addSizeConstraint (pctxt, &sessionDescription_lsize1);
+
+   stat = encodeBMPString (pctxt, pvalue->sessionDescription, 0);
+   if (stat != ASN_OK) return stat;
+
+   /* encode dataType */
+
+   stat = asn1PE_H245CommunicationModeTableEntry_dataType (pctxt, &pvalue->dataType);
+   if (stat != ASN_OK) return stat;
+
+   /* encode mediaChannel */
+
+   if (pvalue->m.mediaChannelPresent) {
+      stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaChannel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mediaGuaranteedDelivery */
+
+   if (pvalue->m.mediaGuaranteedDeliveryPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mediaGuaranteedDelivery);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mediaControlChannel */
+
+   if (pvalue->m.mediaControlChannelPresent) {
+      stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaControlChannel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode mediaControlGuaranteedDelivery */
+
+   if (pvalue->m.mediaControlGuaranteedDeliveryPresent) {
+      stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mediaControlGuaranteedDelivery);
+      if (stat != ASN_OK) return stat;
+   }
+
+   if (extbit) {
+
+      /* encode extension optional bits length */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* encode optional bits */
+
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.redundancyEncodingPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.sessionDependencyPresent);
+      encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.redundancyEncodingPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245RedundancyEncoding (&lctxt, &pvalue->redundancyEncoding);
+         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.sessionDependencyPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = encodeConsUnsigned (&lctxt, pvalue->sessionDependency, 1U, 255U);
+         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.destinationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245TerminalLabel (&lctxt, &pvalue->destination);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeResponse_communicationModeTable          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CommunicationModeResponse_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeResponse_communicationModeTable* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245CommunicationModeTableEntry (pctxt, ((H245CommunicationModeTableEntry*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeResponse                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CommunicationModeResponse (OOCTXT* pctxt, H245CommunicationModeResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 1);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* communicationModeTable */
+         case 1:
+            stat = asn1PE_H245CommunicationModeResponse_communicationModeTable (pctxt, pvalue->u.communicationModeTable);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalID                                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalID (OOCTXT* pctxt, H245TerminalID* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_mCTerminalIDResponse                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_mCTerminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_mCTerminalIDResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalLabel */
+
+   stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode terminalID */
+
+   stat = asn1PE_H245TerminalID (pctxt, &pvalue->terminalID);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalIDResponse                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_terminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalIDResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalLabel */
+
+   stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode terminalID */
+
+   stat = asn1PE_H245TerminalID (pctxt, &pvalue->terminalID);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceID                                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceID (OOCTXT* pctxt, H245ConferenceID* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_conferenceIDResponse                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_conferenceIDResponse (OOCTXT* pctxt, H245ConferenceResponse_conferenceIDResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalLabel */
+
+   stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode conferenceID */
+
+   stat = asn1PE_H245ConferenceID (pctxt, &pvalue->conferenceID);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  Password                                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245Password (OOCTXT* pctxt, H245Password* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 32, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_passwordResponse                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_passwordResponse (OOCTXT* pctxt, H245ConferenceResponse_passwordResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalLabel */
+
+   stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode password */
+
+   stat = asn1PE_H245Password (pctxt, &pvalue->password);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalListResponse                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_terminalListResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalListResponse* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245TerminalLabel (pctxt, ((H245TerminalLabel*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_makeMeChairResponse                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_makeMeChairResponse (OOCTXT* pctxt, H245ConferenceResponse_makeMeChairResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* grantedChairToken */
+         case 1:
+            /* NULL */
+            break;
+
+         /* deniedChairToken */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_extensionAddressResponse               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_extensionAddressResponse (OOCTXT* pctxt, H245ConferenceResponse_extensionAddressResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode extensionAddress */
+
+   stat = asn1PE_H245TerminalID (pctxt, &pvalue->extensionAddress);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_chairTokenOwnerResponse                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_chairTokenOwnerResponse (OOCTXT* pctxt, H245ConferenceResponse_chairTokenOwnerResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalLabel */
+
+   stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode terminalID */
+
+   stat = asn1PE_H245TerminalID (pctxt, &pvalue->terminalID);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_terminalCertificateResponse            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_terminalCertificateResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalCertificateResponse* pvalue)
+{
+   static Asn1SizeCnst certificateResponse_lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalLabelPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.certificateResponsePresent);
+
+   /* encode terminalLabel */
+
+   if (pvalue->m.terminalLabelPresent) {
+      stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode certificateResponse */
+
+   if (pvalue->m.certificateResponsePresent) {
+      addSizeConstraint (pctxt, &certificateResponse_lsize1);
+
+      stat = encodeOctetString (pctxt, pvalue->certificateResponse.numocts, pvalue->certificateResponse.data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_broadcastMyLogicalChannelResponse      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_broadcastMyLogicalChannelResponse (OOCTXT* pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* grantedBroadcastMyLogicalChannel */
+         case 1:
+            /* NULL */
+            break;
+
+         /* deniedBroadcastMyLogicalChannel */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_makeTerminalBroadcasterResponse        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_makeTerminalBroadcasterResponse (OOCTXT* pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* grantedMakeTerminalBroadcaster */
+         case 1:
+            /* NULL */
+            break;
+
+         /* deniedMakeTerminalBroadcaster */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse_sendThisSourceResponse                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse_sendThisSourceResponse (OOCTXT* pctxt, H245ConferenceResponse_sendThisSourceResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* grantedSendThisSource */
+         case 1:
+            /* NULL */
+            break;
+
+         /* deniedSendThisSource */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalInformation                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalInformation (OOCTXT* pctxt, H245TerminalInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalLabel */
+
+   stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode terminalID */
+
+   stat = asn1PE_H245TerminalID (pctxt, &pvalue->terminalID);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245TerminalInformation                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245TerminalInformation (OOCTXT* pctxt, H245_SeqOfH245TerminalInformation* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245TerminalInformation (pctxt, ((H245TerminalInformation*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestAllTerminalIDsResponse                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestAllTerminalIDsResponse (OOCTXT* pctxt, H245RequestAllTerminalIDsResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalInformation */
+
+   stat = asn1PE_H245_SeqOfH245TerminalInformation (pctxt, &pvalue->terminalInformation);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCResponse_reject                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RemoteMCResponse_reject (OOCTXT* pctxt, H245RemoteMCResponse_reject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* unspecified */
+         case 1:
+            /* NULL */
+            break;
+
+         /* functionNotSupported */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RemoteMCResponse                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RemoteMCResponse (OOCTXT* pctxt, H245RemoteMCResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* accept */
+         case 1:
+            /* NULL */
+            break;
+
+         /* reject */
+         case 2:
+            stat = asn1PE_H245RemoteMCResponse_reject (pctxt, pvalue->u.reject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceResponse                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceResponse (OOCTXT* pctxt, H245ConferenceResponse* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 8);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* mCTerminalIDResponse */
+         case 1:
+            stat = asn1PE_H245ConferenceResponse_mCTerminalIDResponse (pctxt, pvalue->u.mCTerminalIDResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* terminalIDResponse */
+         case 2:
+            stat = asn1PE_H245ConferenceResponse_terminalIDResponse (pctxt, pvalue->u.terminalIDResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* conferenceIDResponse */
+         case 3:
+            stat = asn1PE_H245ConferenceResponse_conferenceIDResponse (pctxt, pvalue->u.conferenceIDResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* passwordResponse */
+         case 4:
+            stat = asn1PE_H245ConferenceResponse_passwordResponse (pctxt, pvalue->u.passwordResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* terminalListResponse */
+         case 5:
+            stat = asn1PE_H245ConferenceResponse_terminalListResponse (pctxt, pvalue->u.terminalListResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* videoCommandReject */
+         case 6:
+            /* NULL */
+            break;
+
+         /* terminalDropReject */
+         case 7:
+            /* NULL */
+            break;
+
+         /* makeMeChairResponse */
+         case 8:
+            stat = asn1PE_H245ConferenceResponse_makeMeChairResponse (pctxt, pvalue->u.makeMeChairResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* extensionAddressResponse */
+         case 9:
+            stat = asn1PE_H245ConferenceResponse_extensionAddressResponse (&lctxt, pvalue->u.extensionAddressResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* chairTokenOwnerResponse */
+         case 10:
+            stat = asn1PE_H245ConferenceResponse_chairTokenOwnerResponse (&lctxt, pvalue->u.chairTokenOwnerResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* terminalCertificateResponse */
+         case 11:
+            stat = asn1PE_H245ConferenceResponse_terminalCertificateResponse (&lctxt, pvalue->u.terminalCertificateResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* broadcastMyLogicalChannelResponse */
+         case 12:
+            stat = asn1PE_H245ConferenceResponse_broadcastMyLogicalChannelResponse (&lctxt, pvalue->u.broadcastMyLogicalChannelResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* makeTerminalBroadcasterResponse */
+         case 13:
+            stat = asn1PE_H245ConferenceResponse_makeTerminalBroadcasterResponse (&lctxt, pvalue->u.makeTerminalBroadcasterResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* sendThisSourceResponse */
+         case 14:
+            stat = asn1PE_H245ConferenceResponse_sendThisSourceResponse (&lctxt, pvalue->u.sendThisSourceResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* requestAllTerminalIDsResponse */
+         case 15:
+            stat = asn1PE_H245RequestAllTerminalIDsResponse (&lctxt, pvalue->u.requestAllTerminalIDsResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* remoteMCResponse */
+         case 16:
+            stat = asn1PE_H245RemoteMCResponse (&lctxt, pvalue->u.remoteMCResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_callInformation                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkResponse_callInformation (OOCTXT* pctxt, H245MultilinkResponse_callInformation* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode dialingInformation */
+
+   stat = asn1PE_H245DialingInformation (pctxt, &pvalue->dialingInformation);
+   if (stat != ASN_OK) return stat;
+
+   /* encode callAssociationNumber */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->callAssociationNumber, 0U, ASN1UINT_MAX);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection_responseCode_rejected     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkResponse_addConnection_responseCode_rejected (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode_rejected* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* connectionsNotAvailable */
+         case 1:
+            /* NULL */
+            break;
+
+         /* userRejected */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection_responseCode              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkResponse_addConnection_responseCode (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* accepted */
+         case 1:
+            /* NULL */
+            break;
+
+         /* rejected */
+         case 2:
+            stat = asn1PE_H245MultilinkResponse_addConnection_responseCode_rejected (pctxt, pvalue->u.rejected);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_addConnection                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkResponse_addConnection (OOCTXT* pctxt, H245MultilinkResponse_addConnection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode responseCode */
+
+   stat = asn1PE_H245MultilinkResponse_addConnection_responseCode (pctxt, &pvalue->responseCode);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_removeConnection                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkResponse_removeConnection (OOCTXT* pctxt, H245MultilinkResponse_removeConnection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode connectionIdentifier */
+
+   stat = asn1PE_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse_maximumHeaderInterval                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkResponse_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkResponse_maximumHeaderInterval* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode currentInterval */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->currentInterval, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkResponse                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkResponse (OOCTXT* pctxt, H245MultilinkResponse* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* callInformation */
+         case 2:
+            stat = asn1PE_H245MultilinkResponse_callInformation (pctxt, pvalue->u.callInformation);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* addConnection */
+         case 3:
+            stat = asn1PE_H245MultilinkResponse_addConnection (pctxt, pvalue->u.addConnection);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* removeConnection */
+         case 4:
+            stat = asn1PE_H245MultilinkResponse_removeConnection (pctxt, pvalue->u.removeConnection);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* maximumHeaderInterval */
+         case 5:
+            stat = asn1PE_H245MultilinkResponse_maximumHeaderInterval (pctxt, pvalue->u.maximumHeaderInterval);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateAcknowledge                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245LogicalChannelRateAcknowledge (OOCTXT* pctxt, H245LogicalChannelRateAcknowledge* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode logicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maximumBitRate */
+
+   stat = asn1PE_H245MaximumBitRate (pctxt, pvalue->maximumBitRate);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRejectReason                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245LogicalChannelRateRejectReason (OOCTXT* pctxt, H245LogicalChannelRateRejectReason* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* undefinedReason */
+         case 1:
+            /* NULL */
+            break;
+
+         /* insufficientResources */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateReject                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245LogicalChannelRateReject (OOCTXT* pctxt, H245LogicalChannelRateReject* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.currentMaximumBitRatePresent);
+
+   /* encode sequenceNumber */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode logicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rejectReason */
+
+   stat = asn1PE_H245LogicalChannelRateRejectReason (pctxt, &pvalue->rejectReason);
+   if (stat != ASN_OK) return stat;
+
+   /* encode currentMaximumBitRate */
+
+   if (pvalue->m.currentMaximumBitRatePresent) {
+      stat = asn1PE_H245MaximumBitRate (pctxt, pvalue->currentMaximumBitRate);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ResponseMessage                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ResponseMessage (OOCTXT* pctxt, H245ResponseMessage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 19);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 18);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* masterSlaveDeterminationAck */
+         case 2:
+            stat = asn1PE_H245MasterSlaveDeterminationAck (pctxt, pvalue->u.masterSlaveDeterminationAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* masterSlaveDeterminationReject */
+         case 3:
+            stat = asn1PE_H245MasterSlaveDeterminationReject (pctxt, pvalue->u.masterSlaveDeterminationReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* terminalCapabilitySetAck */
+         case 4:
+            stat = asn1PE_H245TerminalCapabilitySetAck (pctxt, pvalue->u.terminalCapabilitySetAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* terminalCapabilitySetReject */
+         case 5:
+            stat = asn1PE_H245TerminalCapabilitySetReject (pctxt, pvalue->u.terminalCapabilitySetReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* openLogicalChannelAck */
+         case 6:
+            stat = asn1PE_H245OpenLogicalChannelAck (pctxt, pvalue->u.openLogicalChannelAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* openLogicalChannelReject */
+         case 7:
+            stat = asn1PE_H245OpenLogicalChannelReject (pctxt, pvalue->u.openLogicalChannelReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* closeLogicalChannelAck */
+         case 8:
+            stat = asn1PE_H245CloseLogicalChannelAck (pctxt, pvalue->u.closeLogicalChannelAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestChannelCloseAck */
+         case 9:
+            stat = asn1PE_H245RequestChannelCloseAck (pctxt, pvalue->u.requestChannelCloseAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestChannelCloseReject */
+         case 10:
+            stat = asn1PE_H245RequestChannelCloseReject (pctxt, pvalue->u.requestChannelCloseReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* multiplexEntrySendAck */
+         case 11:
+            stat = asn1PE_H245MultiplexEntrySendAck (pctxt, pvalue->u.multiplexEntrySendAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* multiplexEntrySendReject */
+         case 12:
+            stat = asn1PE_H245MultiplexEntrySendReject (pctxt, pvalue->u.multiplexEntrySendReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestMultiplexEntryAck */
+         case 13:
+            stat = asn1PE_H245RequestMultiplexEntryAck (pctxt, pvalue->u.requestMultiplexEntryAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestMultiplexEntryReject */
+         case 14:
+            stat = asn1PE_H245RequestMultiplexEntryReject (pctxt, pvalue->u.requestMultiplexEntryReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestModeAck */
+         case 15:
+            stat = asn1PE_H245RequestModeAck (pctxt, pvalue->u.requestModeAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestModeReject */
+         case 16:
+            stat = asn1PE_H245RequestModeReject (pctxt, pvalue->u.requestModeReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* roundTripDelayResponse */
+         case 17:
+            stat = asn1PE_H245RoundTripDelayResponse (pctxt, pvalue->u.roundTripDelayResponse);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* maintenanceLoopAck */
+         case 18:
+            stat = asn1PE_H245MaintenanceLoopAck (pctxt, pvalue->u.maintenanceLoopAck);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* maintenanceLoopReject */
+         case 19:
+            stat = asn1PE_H245MaintenanceLoopReject (pctxt, pvalue->u.maintenanceLoopReject);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 20);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* communicationModeResponse */
+         case 20:
+            stat = asn1PE_H245CommunicationModeResponse (&lctxt, pvalue->u.communicationModeResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* conferenceResponse */
+         case 21:
+            stat = asn1PE_H245ConferenceResponse (&lctxt, pvalue->u.conferenceResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multilinkResponse */
+         case 22:
+            stat = asn1PE_H245MultilinkResponse (&lctxt, pvalue->u.multilinkResponse);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* logicalChannelRateAcknowledge */
+         case 23:
+            stat = asn1PE_H245LogicalChannelRateAcknowledge (&lctxt, pvalue->u.logicalChannelRateAcknowledge);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* logicalChannelRateReject */
+         case 24:
+            stat = asn1PE_H245LogicalChannelRateReject (&lctxt, pvalue->u.logicalChannelRateReject);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MaintenanceLoopOffCommand                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MaintenanceLoopOffCommand (OOCTXT* pctxt, H245MaintenanceLoopOffCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest_capabilityTabl  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest_capabilityDesc  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245CapabilityDescriptorNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet_specificRequest                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityTableEntryNumbersPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityDescriptorNumbersPresent);
+
+   /* encode multiplexCapability */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multiplexCapability);
+   if (stat != ASN_OK) return stat;
+
+   /* encode capabilityTableEntryNumbers */
+
+   if (pvalue->m.capabilityTableEntryNumbersPresent) {
+      stat = asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (pctxt, &pvalue->capabilityTableEntryNumbers);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode capabilityDescriptorNumbers */
+
+   if (pvalue->m.capabilityDescriptorNumbersPresent) {
+      stat = asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (pctxt, &pvalue->capabilityDescriptorNumbers);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SendTerminalCapabilitySet                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245SendTerminalCapabilitySet (OOCTXT* pctxt, H245SendTerminalCapabilitySet* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* specificRequest */
+         case 1:
+            stat = asn1PE_H245SendTerminalCapabilitySet_specificRequest (pctxt, pvalue->u.specificRequest);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* genericRequest */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCommand_encryptionAlgorithmID                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EncryptionCommand_encryptionAlgorithmID (OOCTXT* pctxt, H245EncryptionCommand_encryptionAlgorithmID* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode h233AlgorithmIdentifier */
+
+   stat = asn1PE_H245SequenceNumber (pctxt, pvalue->h233AlgorithmIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   /* encode associatedAlgorithm */
+
+   stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->associatedAlgorithm);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EncryptionCommand (OOCTXT* pctxt, H245EncryptionCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* encryptionSE */
+         case 1:
+            stat = encodeOctetString (pctxt, pvalue->u.encryptionSE->numocts, pvalue->u.encryptionSE->data);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* encryptionIVRequest */
+         case 2:
+            /* NULL */
+            break;
+
+         /* encryptionAlgorithmID */
+         case 3:
+            stat = asn1PE_H245EncryptionCommand_encryptionAlgorithmID (pctxt, pvalue->u.encryptionAlgorithmID);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand_scope                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FlowControlCommand_scope (OOCTXT* pctxt, H245FlowControlCommand_scope* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* logicalChannelNumber */
+      case 1:
+         stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelNumber);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      /* resourceID */
+      case 2:
+         stat = encodeConsUnsigned (pctxt, pvalue->u.resourceID, 0U, 65535U);
+         if (stat != ASN_OK) return stat;
+
+         break;
+
+      /* wholeMultiplex */
+      case 3:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand_restriction                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FlowControlCommand_restriction (OOCTXT* pctxt, H245FlowControlCommand_restriction* 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)
+   {
+      /* maximumBitRate */
+      case 1:
+         stat = encodeConsUnsigned (pctxt, pvalue->u.maximumBitRate, 0U, 16777215U);
+         if (stat != ASN_OK) return stat;
+
+         break;
+
+      /* noRestriction */
+      case 2:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlCommand                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FlowControlCommand (OOCTXT* pctxt, H245FlowControlCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode scope */
+
+   stat = asn1PE_H245FlowControlCommand_scope (pctxt, &pvalue->scope);
+   if (stat != ASN_OK) return stat;
+
+   /* encode restriction */
+
+   stat = asn1PE_H245FlowControlCommand_restriction (pctxt, &pvalue->restriction);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand_gstnOptions                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EndSessionCommand_gstnOptions (OOCTXT* pctxt, H245EndSessionCommand_gstnOptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 5);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* telephonyMode */
+         case 1:
+            /* NULL */
+            break;
+
+         /* v8bis */
+         case 2:
+            /* NULL */
+            break;
+
+         /* v34DSVD */
+         case 3:
+            /* NULL */
+            break;
+
+         /* v34DuplexFAX */
+         case 4:
+            /* NULL */
+            break;
+
+         /* v34H324 */
+         case 5:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand_isdnOptions                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EndSessionCommand_isdnOptions (OOCTXT* pctxt, H245EndSessionCommand_isdnOptions* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* telephonyMode */
+         case 1:
+            /* NULL */
+            break;
+
+         /* v140 */
+         case 2:
+            /* NULL */
+            break;
+
+         /* terminalOnHold */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EndSessionCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EndSessionCommand (OOCTXT* pctxt, H245EndSessionCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* disconnect */
+         case 2:
+            /* NULL */
+            break;
+
+         /* gstnOptions */
+         case 3:
+            stat = asn1PE_H245EndSessionCommand_gstnOptions (pctxt, pvalue->u.gstnOptions);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* isdnOptions */
+         case 4:
+            stat = asn1PE_H245EndSessionCommand_isdnOptions (&lctxt, pvalue->u.isdnOptions);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoFastUpdateGOB              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_videoFastUpdateGOB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* encode firstGOB */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->firstGOB, 0U, 17U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode numberOfGOBs */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfGOBs, 1U, 18U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoFastUpdateMB               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_videoFastUpdateMB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.firstGOBPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.firstMBPresent);
+
+   /* encode firstGOB */
+
+   if (pvalue->m.firstGOBPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->firstGOB, 0U, 255U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode firstMB */
+
+   if (pvalue->m.firstMBPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->firstMB, 1U, 8192U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode numberOfMBs */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfMBs, 1U, 8192U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  KeyProtectionMethod                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245KeyProtectionMethod (OOCTXT* pctxt, H245KeyProtectionMethod* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode secureChannel */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->secureChannel);
+   if (stat != ASN_OK) return stat;
+
+   /* encode sharedSecret */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->sharedSecret);
+   if (stat != ASN_OK) return stat;
+
+   /* encode certProtectedKey */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->certProtectedKey);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  EncryptionUpdateRequest                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245EncryptionUpdateRequest (OOCTXT* pctxt, H245EncryptionUpdateRequest* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.keyProtectionMethodPresent);
+
+   /* encode keyProtectionMethod */
+
+   if (pvalue->m.keyProtectionMethodPresent) {
+      stat = asn1PE_H245KeyProtectionMethod (pctxt, &pvalue->keyProtectionMethod);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_progressiveRefinementStart_rep  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* doOneProgression */
+         case 1:
+            /* NULL */
+            break;
+
+         /* doContinuousProgressions */
+         case 2:
+            /* NULL */
+            break;
+
+         /* doOneIndependentProgression */
+         case 3:
+            /* NULL */
+            break;
+
+         /* doContinuousIndependentProgressions */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_progressiveRefinementStart      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode repeatCount */
+
+   stat = asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (pctxt, &pvalue->repeatCount);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_videoBadMBs                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_videoBadMBs (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoBadMBs* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode firstMB */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->firstMB, 1U, 9216U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode numberOfMBs */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfMBs, 1U, 9216U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode temporalReference */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->temporalReference, 0U, 1023U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  PictureReference                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245PictureReference (OOCTXT* pctxt, H245PictureReference* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* pictureNumber */
+         case 1:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.pictureNumber, 0U, 1023U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* longTermPictureIndex */
+         case 2:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.longTermPictureIndex, 0U, 255U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  _SeqOfH245PictureReference                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245_SeqOfH245PictureReference (OOCTXT* pctxt, H245_SeqOfH245PictureReference* pvalue)
+{
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+   ASN1UINT enclen, fraglen;
+
+   enclen = fraglen = xx1 = 0;
+   pnode = pvalue->head;
+   for (;;) {
+      /* encode length determinant */
+
+      stat = encodeLength (pctxt, (pvalue->count - enclen));
+      if (stat < 0) return stat;
+
+      fraglen = stat;
+      enclen += fraglen;
+      /* encode elements */
+
+      for (; xx1 < enclen; xx1++) {
+         stat = asn1PE_H245PictureReference (pctxt, ((H245PictureReference*)pnode->data));
+         if (stat != ASN_OK) return stat;
+         pnode = pnode->next;
+      }
+      if ( pvalue->count == enclen && fraglen < 16384) {
+         break;
+      }
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type_lostPartialPicture              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type_lostPartialPicture (OOCTXT* pctxt, H245MiscellaneousCommand_type_lostPartialPicture* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode pictureReference */
+
+   stat = asn1PE_H245PictureReference (pctxt, &pvalue->pictureReference);
+   if (stat != ASN_OK) return stat;
+
+   /* encode firstMB */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->firstMB, 1U, 9216U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode numberOfMBs */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfMBs, 1U, 9216U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand_type                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousCommand_type (OOCTXT* pctxt, H245MiscellaneousCommand_type* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 10);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* equaliseDelay */
+         case 1:
+            /* NULL */
+            break;
+
+         /* zeroDelay */
+         case 2:
+            /* NULL */
+            break;
+
+         /* multipointModeCommand */
+         case 3:
+            /* NULL */
+            break;
+
+         /* cancelMultipointModeCommand */
+         case 4:
+            /* NULL */
+            break;
+
+         /* videoFreezePicture */
+         case 5:
+            /* NULL */
+            break;
+
+         /* videoFastUpdatePicture */
+         case 6:
+            /* NULL */
+            break;
+
+         /* videoFastUpdateGOB */
+         case 7:
+            stat = asn1PE_H245MiscellaneousCommand_type_videoFastUpdateGOB (pctxt, pvalue->u.videoFastUpdateGOB);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* videoTemporalSpatialTradeOff */
+         case 8:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.videoTemporalSpatialTradeOff, 0U, 31U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* videoSendSyncEveryGOB */
+         case 9:
+            /* NULL */
+            break;
+
+         /* videoSendSyncEveryGOBCancel */
+         case 10:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* videoFastUpdateMB */
+         case 11:
+            stat = asn1PE_H245MiscellaneousCommand_type_videoFastUpdateMB (&lctxt, pvalue->u.videoFastUpdateMB);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* maxH223MUXPDUsize */
+         case 12:
+            stat = encodeConsUnsigned (&lctxt, pvalue->u.maxH223MUXPDUsize, 1U, 65535U);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* encryptionUpdate */
+         case 13:
+            stat = asn1PE_H245EncryptionSync (&lctxt, pvalue->u.encryptionUpdate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* encryptionUpdateRequest */
+         case 14:
+            stat = asn1PE_H245EncryptionUpdateRequest (&lctxt, pvalue->u.encryptionUpdateRequest);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* switchReceiveMediaOff */
+         case 15:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* switchReceiveMediaOn */
+         case 16:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* progressiveRefinementStart */
+         case 17:
+            stat = asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart (&lctxt, pvalue->u.progressiveRefinementStart);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* progressiveRefinementAbortOne */
+         case 18:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* progressiveRefinementAbortContinuous */
+         case 19:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* videoBadMBs */
+         case 20:
+            stat = asn1PE_H245MiscellaneousCommand_type_videoBadMBs (&lctxt, pvalue->u.videoBadMBs);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* lostPicture */
+         case 21:
+            stat = asn1PE_H245_SeqOfH245PictureReference (&lctxt, pvalue->u.lostPicture);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* lostPartialPicture */
+         case 22:
+            stat = asn1PE_H245MiscellaneousCommand_type_lostPartialPicture (&lctxt, pvalue->u.lostPartialPicture);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* recoveryReferencePicture */
+         case 23:
+            stat = asn1PE_H245_SeqOfH245PictureReference (&lctxt, pvalue->u.recoveryReferencePicture);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousCommand                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousCommand (OOCTXT* pctxt, H245MiscellaneousCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode logicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode type */
+
+   stat = asn1PE_H245MiscellaneousCommand_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeCommand_communicationModeTable           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CommunicationModeCommand_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeCommand_communicationModeTable* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+   DListNode* pnode;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->count);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+   pnode = pvalue->head;
+
+   for (xx1 = 0; xx1 < pvalue->count; xx1++) {
+      stat = asn1PE_H245CommunicationModeTableEntry (pctxt, ((H245CommunicationModeTableEntry*)pnode->data));
+      if (stat != ASN_OK) return stat;
+      pnode = pnode->next;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommunicationModeCommand                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CommunicationModeCommand (OOCTXT* pctxt, H245CommunicationModeCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode communicationModeTable */
+
+   stat = asn1PE_H245CommunicationModeCommand_communicationModeTable (pctxt, &pvalue->communicationModeTable);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SubstituteConferenceIDCommand_conferenceIdentifier        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245SubstituteConferenceIDCommand_conferenceIdentifier (OOCTXT* pctxt, H245SubstituteConferenceIDCommand_conferenceIdentifier* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  SubstituteConferenceIDCommand                             */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245SubstituteConferenceIDCommand (OOCTXT* pctxt, H245SubstituteConferenceIDCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode conferenceIdentifier */
+
+   stat = asn1PE_H245SubstituteConferenceIDCommand_conferenceIdentifier (pctxt, &pvalue->conferenceIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceCommand                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceCommand (OOCTXT* pctxt, H245ConferenceCommand* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 7);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* broadcastMyLogicalChannel */
+         case 1:
+            stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.broadcastMyLogicalChannel);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cancelBroadcastMyLogicalChannel */
+         case 2:
+            stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.cancelBroadcastMyLogicalChannel);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* makeTerminalBroadcaster */
+         case 3:
+            stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.makeTerminalBroadcaster);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cancelMakeTerminalBroadcaster */
+         case 4:
+            /* NULL */
+            break;
+
+         /* sendThisSource */
+         case 5:
+            stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.sendThisSource);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* cancelSendThisSource */
+         case 6:
+            /* NULL */
+            break;
+
+         /* dropConference */
+         case 7:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* substituteConferenceIDCommand */
+         case 8:
+            stat = asn1PE_H245SubstituteConferenceIDCommand (&lctxt, pvalue->u.substituteConferenceIDCommand);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration_h223ModeChange               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223MultiplexReconfiguration_h223ModeChange (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223ModeChange* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* toLevel0 */
+         case 1:
+            /* NULL */
+            break;
+
+         /* toLevel1 */
+         case 2:
+            /* NULL */
+            break;
+
+         /* toLevel2 */
+         case 3:
+            /* NULL */
+            break;
+
+         /* toLevel2withOptionalHeader */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration_h223AnnexADoubleFlag         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* start */
+         case 1:
+            /* NULL */
+            break;
+
+         /* stop */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223MultiplexReconfiguration                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223MultiplexReconfiguration (OOCTXT* pctxt, H245H223MultiplexReconfiguration* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* h223ModeChange */
+         case 1:
+            stat = asn1PE_H245H223MultiplexReconfiguration_h223ModeChange (pctxt, pvalue->u.h223ModeChange);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h223AnnexADoubleFlag */
+         case 2:
+            stat = asn1PE_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (pctxt, pvalue->u.h223AnnexADoubleFlag);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1_clockRecovery                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_clockRecovery* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nullClockRecovery */
+         case 1:
+            /* NULL */
+            break;
+
+         /* srtsClockRecovery */
+         case 2:
+            /* NULL */
+            break;
+
+         /* adaptiveClockRecovery */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1_errorCorrection                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_errorCorrection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nullErrorCorrection */
+         case 1:
+            /* NULL */
+            break;
+
+         /* longInterleaver */
+         case 2:
+            /* NULL */
+            break;
+
+         /* shortInterleaver */
+         case 3:
+            /* NULL */
+            break;
+
+         /* errorCorrectionOnly */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal1                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode clockRecovery */
+
+   stat = asn1PE_H245NewATMVCCommand_aal_aal1_clockRecovery (pctxt, &pvalue->clockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   /* encode errorCorrection */
+
+   stat = asn1PE_H245NewATMVCCommand_aal_aal1_errorCorrection (pctxt, &pvalue->errorCorrection);
+   if (stat != ASN_OK) return stat;
+
+   /* encode structuredDataTransfer */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->structuredDataTransfer);
+   if (stat != ASN_OK) return stat;
+
+   /* encode partiallyFilledCells */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partiallyFilledCells);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal_aal5                                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal_aal5 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal5* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardMaximumSDUSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->forwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode backwardMaximumSDUSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->backwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_aal                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand_aal (OOCTXT* pctxt, H245NewATMVCCommand_aal* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* aal1 */
+         case 1:
+            stat = asn1PE_H245NewATMVCCommand_aal_aal1 (pctxt, pvalue->u.aal1);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* aal5 */
+         case 2:
+            stat = asn1PE_H245NewATMVCCommand_aal_aal5 (pctxt, pvalue->u.aal5);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_multiplex                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_multiplex* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* noMultiplex */
+         case 1:
+            /* NULL */
+            break;
+
+         /* transportStream */
+         case 2:
+            /* NULL */
+            break;
+
+         /* programStream */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_reverseParameters_multiplex               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters_multiplex* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* noMultiplex */
+         case 1:
+            /* NULL */
+            break;
+
+         /* transportStream */
+         case 2:
+            /* NULL */
+            break;
+
+         /* programStream */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand_reverseParameters                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand_reverseParameters (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRateLockedToPCRClock */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToPCRClock);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRateLockedToNetworkClock */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToNetworkClock);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplex */
+
+   stat = asn1PE_H245NewATMVCCommand_reverseParameters_multiplex (pctxt, &pvalue->multiplex);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCCommand                                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCCommand (OOCTXT* pctxt, H245NewATMVCCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode resourceID */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->resourceID, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRateLockedToPCRClock */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToPCRClock);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRateLockedToNetworkClock */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToNetworkClock);
+   if (stat != ASN_OK) return stat;
+
+   /* encode aal */
+
+   stat = asn1PE_H245NewATMVCCommand_aal (pctxt, &pvalue->aal);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplex */
+
+   stat = asn1PE_H245NewATMVCCommand_multiplex (pctxt, &pvalue->multiplex);
+   if (stat != ASN_OK) return stat;
+
+   /* encode reverseParameters */
+
+   stat = asn1PE_H245NewATMVCCommand_reverseParameters (pctxt, &pvalue->reverseParameters);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationCommand_status              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MobileMultilinkReconfigurationCommand_status (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand_status* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* synchronized_ */
+         case 1:
+            /* NULL */
+            break;
+
+         /* reconfiguration */
+         case 2:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationCommand                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MobileMultilinkReconfigurationCommand (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sampleSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sampleSize, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode samplesPerFrame */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->samplesPerFrame, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode status */
+
+   stat = asn1PE_H245MobileMultilinkReconfigurationCommand_status (pctxt, &pvalue->status);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  CommandMessage                                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245CommandMessage (OOCTXT* pctxt, H245CommandMessage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 7);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* maintenanceLoopOffCommand */
+         case 2:
+            stat = asn1PE_H245MaintenanceLoopOffCommand (pctxt, pvalue->u.maintenanceLoopOffCommand);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* sendTerminalCapabilitySet */
+         case 3:
+            stat = asn1PE_H245SendTerminalCapabilitySet (pctxt, pvalue->u.sendTerminalCapabilitySet);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* encryptionCommand */
+         case 4:
+            stat = asn1PE_H245EncryptionCommand (pctxt, pvalue->u.encryptionCommand);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* flowControlCommand */
+         case 5:
+            stat = asn1PE_H245FlowControlCommand (pctxt, pvalue->u.flowControlCommand);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* endSessionCommand */
+         case 6:
+            stat = asn1PE_H245EndSessionCommand (pctxt, pvalue->u.endSessionCommand);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* miscellaneousCommand */
+         case 7:
+            stat = asn1PE_H245MiscellaneousCommand (pctxt, pvalue->u.miscellaneousCommand);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* communicationModeCommand */
+         case 8:
+            stat = asn1PE_H245CommunicationModeCommand (&lctxt, pvalue->u.communicationModeCommand);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* conferenceCommand */
+         case 9:
+            stat = asn1PE_H245ConferenceCommand (&lctxt, pvalue->u.conferenceCommand);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* h223MultiplexReconfiguration */
+         case 10:
+            stat = asn1PE_H245H223MultiplexReconfiguration (&lctxt, pvalue->u.h223MultiplexReconfiguration);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* newATMVCCommand */
+         case 11:
+            stat = asn1PE_H245NewATMVCCommand (&lctxt, pvalue->u.newATMVCCommand);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* mobileMultilinkReconfigurationCommand */
+         case 12:
+            stat = asn1PE_H245MobileMultilinkReconfigurationCommand (&lctxt, pvalue->u.mobileMultilinkReconfigurationCommand);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotUnderstood                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FunctionNotUnderstood (OOCTXT* pctxt, H245FunctionNotUnderstood* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* request */
+      case 1:
+         stat = asn1PE_H245RequestMessage (pctxt, pvalue->u.request);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      /* response */
+      case 2:
+         stat = asn1PE_H245ResponseMessage (pctxt, pvalue->u.response);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      /* command */
+      case 3:
+         stat = asn1PE_H245CommandMessage (pctxt, pvalue->u.command);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MasterSlaveDeterminationRelease                           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MasterSlaveDeterminationRelease (OOCTXT* pctxt, H245MasterSlaveDeterminationRelease* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalCapabilitySetRelease                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalCapabilitySetRelease (OOCTXT* pctxt, H245TerminalCapabilitySetRelease* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  OpenLogicalChannelConfirm                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245OpenLogicalChannelConfirm (OOCTXT* pctxt, H245OpenLogicalChannelConfirm* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestChannelCloseRelease                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestChannelCloseRelease (OOCTXT* pctxt, H245RequestChannelCloseRelease* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardLogicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendRelease_multiplexTableEntryNumber       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendRelease_multiplexTableEntryNumber* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultiplexEntrySendRelease                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultiplexEntrySendRelease (OOCTXT* pctxt, H245MultiplexEntrySendRelease* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode multiplexTableEntryNumber */
+
+   stat = asn1PE_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRelease_entryNumbers                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryRelease_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryRelease_entryNumbers* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 };
+   int stat = ASN_OK;
+   ASN1UINT xx1;
+
+   /* encode length determinant */
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeLength (pctxt, pvalue->n);
+   if (stat < 0) return stat;
+
+   /* encode elements */
+
+   for (xx1 = 0; xx1 < pvalue->n; xx1++) {
+      stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestMultiplexEntryRelease                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestMultiplexEntryRelease (OOCTXT* pctxt, H245RequestMultiplexEntryRelease* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode entryNumbers */
+
+   stat = asn1PE_H245RequestMultiplexEntryRelease_entryNumbers (pctxt, &pvalue->entryNumbers);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  RequestModeRelease                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245RequestModeRelease (OOCTXT* pctxt, H245RequestModeRelease* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication_type_videoNotDecodedMBs           */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousIndication_type_videoNotDecodedMBs (OOCTXT* pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode firstMB */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->firstMB, 1U, 8192U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode numberOfMBs */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->numberOfMBs, 1U, 8192U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode temporalReference */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->temporalReference, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication_type                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousIndication_type (OOCTXT* pctxt, H245MiscellaneousIndication_type* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 10);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* logicalChannelActive */
+         case 1:
+            /* NULL */
+            break;
+
+         /* logicalChannelInactive */
+         case 2:
+            /* NULL */
+            break;
+
+         /* multipointConference */
+         case 3:
+            /* NULL */
+            break;
+
+         /* cancelMultipointConference */
+         case 4:
+            /* NULL */
+            break;
+
+         /* multipointZeroComm */
+         case 5:
+            /* NULL */
+            break;
+
+         /* cancelMultipointZeroComm */
+         case 6:
+            /* NULL */
+            break;
+
+         /* multipointSecondaryStatus */
+         case 7:
+            /* NULL */
+            break;
+
+         /* cancelMultipointSecondaryStatus */
+         case 8:
+            /* NULL */
+            break;
+
+         /* videoIndicateReadyToActivate */
+         case 9:
+            /* NULL */
+            break;
+
+         /* videoTemporalSpatialTradeOff */
+         case 10:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.videoTemporalSpatialTradeOff, 0U, 31U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* videoNotDecodedMBs */
+         case 11:
+            stat = asn1PE_H245MiscellaneousIndication_type_videoNotDecodedMBs (&lctxt, pvalue->u.videoNotDecodedMBs);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* transportCapability */
+         case 12:
+            stat = asn1PE_H245TransportCapability (&lctxt, pvalue->u.transportCapability);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MiscellaneousIndication                                   */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MiscellaneousIndication (OOCTXT* pctxt, H245MiscellaneousIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode logicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode type */
+
+   stat = asn1PE_H245MiscellaneousIndication_type (pctxt, &pvalue->type);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  JitterIndication_scope                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245JitterIndication_scope (OOCTXT* pctxt, H245JitterIndication_scope* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* logicalChannelNumber */
+      case 1:
+         stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelNumber);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      /* resourceID */
+      case 2:
+         stat = encodeConsUnsigned (pctxt, pvalue->u.resourceID, 0U, 65535U);
+         if (stat != ASN_OK) return stat;
+
+         break;
+
+      /* wholeMultiplex */
+      case 3:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  JitterIndication                                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245JitterIndication (OOCTXT* pctxt, H245JitterIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.skippedFrameCountPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.additionalDecoderBufferPresent);
+
+   /* encode scope */
+
+   stat = asn1PE_H245JitterIndication_scope (pctxt, &pvalue->scope);
+   if (stat != ASN_OK) return stat;
+
+   /* encode estimatedReceivedJitterMantissa */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->estimatedReceivedJitterMantissa, 0U, 3U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode estimatedReceivedJitterExponent */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->estimatedReceivedJitterExponent, 0U, 7U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode skippedFrameCount */
+
+   if (pvalue->m.skippedFrameCountPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->skippedFrameCount, 0U, 15U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode additionalDecoderBuffer */
+
+   if (pvalue->m.additionalDecoderBufferPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->additionalDecoderBuffer, 0U, 262143U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H223SkewIndication                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H223SkewIndication (OOCTXT* pctxt, H245H223SkewIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode logicalChannelNumber1 */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber1);
+   if (stat != ASN_OK) return stat;
+
+   /* encode logicalChannelNumber2 */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber2);
+   if (stat != ASN_OK) return stat;
+
+   /* encode skew */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->skew, 0U, 4095U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1_clockRecovery                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_clockRecovery* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nullClockRecovery */
+         case 1:
+            /* NULL */
+            break;
+
+         /* srtsClockRecovery */
+         case 2:
+            /* NULL */
+            break;
+
+         /* adaptiveClockRecovery */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1_errorCorrection               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_errorCorrection* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nullErrorCorrection */
+         case 1:
+            /* NULL */
+            break;
+
+         /* longInterleaver */
+         case 2:
+            /* NULL */
+            break;
+
+         /* shortInterleaver */
+         case 3:
+            /* NULL */
+            break;
+
+         /* errorCorrectionOnly */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal1                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode clockRecovery */
+
+   stat = asn1PE_H245NewATMVCIndication_aal_aal1_clockRecovery (pctxt, &pvalue->clockRecovery);
+   if (stat != ASN_OK) return stat;
+
+   /* encode errorCorrection */
+
+   stat = asn1PE_H245NewATMVCIndication_aal_aal1_errorCorrection (pctxt, &pvalue->errorCorrection);
+   if (stat != ASN_OK) return stat;
+
+   /* encode structuredDataTransfer */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->structuredDataTransfer);
+   if (stat != ASN_OK) return stat;
+
+   /* encode partiallyFilledCells */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partiallyFilledCells);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal_aal5                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal_aal5 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal5* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode forwardMaximumSDUSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->forwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode backwardMaximumSDUSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->backwardMaximumSDUSize, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_aal                                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication_aal (OOCTXT* pctxt, H245NewATMVCIndication_aal* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* aal1 */
+         case 1:
+            stat = asn1PE_H245NewATMVCIndication_aal_aal1 (pctxt, pvalue->u.aal1);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* aal5 */
+         case 2:
+            stat = asn1PE_H245NewATMVCIndication_aal_aal5 (pctxt, pvalue->u.aal5);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_multiplex                              */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_multiplex* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* noMultiplex */
+         case 1:
+            /* NULL */
+            break;
+
+         /* transportStream */
+         case 2:
+            /* NULL */
+            break;
+
+         /* programStream */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_reverseParameters_multiplex            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters_multiplex* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* noMultiplex */
+         case 1:
+            /* NULL */
+            break;
+
+         /* transportStream */
+         case 2:
+            /* NULL */
+            break;
+
+         /* programStream */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication_reverseParameters                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication_reverseParameters (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRateLockedToPCRClock */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToPCRClock);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRateLockedToNetworkClock */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToNetworkClock);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplex */
+
+   stat = asn1PE_H245NewATMVCIndication_reverseParameters_multiplex (pctxt, &pvalue->multiplex);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  NewATMVCIndication                                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245NewATMVCIndication (OOCTXT* pctxt, H245NewATMVCIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.reverseParametersPresent);
+
+   encodeBit (pctxt, extbit);
+
+   /* encode resourceID */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->resourceID, 0U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRate */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRateLockedToPCRClock */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToPCRClock);
+   if (stat != ASN_OK) return stat;
+
+   /* encode bitRateLockedToNetworkClock */
+
+   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToNetworkClock);
+   if (stat != ASN_OK) return stat;
+
+   /* encode aal */
+
+   stat = asn1PE_H245NewATMVCIndication_aal (pctxt, &pvalue->aal);
+   if (stat != ASN_OK) return stat;
+
+   /* encode multiplex */
+
+   stat = asn1PE_H245NewATMVCIndication_multiplex (pctxt, &pvalue->multiplex);
+   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.reverseParametersPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.reverseParametersPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         stat = asn1PE_H245NewATMVCIndication_reverseParameters (&lctxt, &pvalue->reverseParameters);
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_userInputSupportIndication            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UserInputIndication_userInputSupportIndication (OOCTXT* pctxt, H245UserInputIndication_userInputSupportIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* basicString */
+         case 2:
+            /* NULL */
+            break;
+
+         /* iA5String */
+         case 3:
+            /* NULL */
+            break;
+
+         /* generalString */
+         case 4:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signal_rtp                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UserInputIndication_signal_rtp (OOCTXT* pctxt, H245UserInputIndication_signal_rtp* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.timestampPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.expirationTimePresent);
+
+   /* encode timestamp */
+
+   if (pvalue->m.timestampPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->timestamp, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode expirationTime */
+
+   if (pvalue->m.expirationTimePresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->expirationTime, 0U, ASN1UINT_MAX);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode logicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signal                                */
+/*                                                            */
+/**************************************************************/
+
+extern EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet;
+
+EXTERN int asn1PE_H245UserInputIndication_signal (OOCTXT* pctxt, H245UserInputIndication_signal* pvalue)
+{
+   static Asn1SizeCnst signalType_lsize1 = { 0, 1, 1, 0 };
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+   ASN1OpenType openType;
+   OOCTXT lctxt;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->m.rtpPayloadIndicationPresent);
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.durationPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpPresent);
+
+   /* encode signalType */
+
+   addSizeConstraint (pctxt, &signalType_lsize1);
+
+   stat = encodeConstrainedStringEx (pctxt, pvalue->signalType, gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet, 8, 5, 7);
+   if (stat != ASN_OK) return stat;
+
+   /* encode duration */
+
+   if (pvalue->m.durationPresent) {
+      stat = encodeConsUnsigned (pctxt, pvalue->duration, 1U, 65535U);
+      if (stat != ASN_OK) return stat;
+
+   }
+
+   /* encode rtp */
+
+   if (pvalue->m.rtpPresent) {
+      stat = asn1PE_H245UserInputIndication_signal_rtp (pctxt, &pvalue->rtp);
+      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.rtpPayloadIndicationPresent);
+      /* encode extension elements */
+
+      if (pvalue->m.rtpPayloadIndicationPresent) {
+         initContext (&lctxt);
+         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+         if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+         /* NULL */
+
+         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);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signalUpdate_rtp                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UserInputIndication_signalUpdate_rtp (OOCTXT* pctxt, H245UserInputIndication_signalUpdate_rtp* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode logicalChannelNumber */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_signalUpdate                          */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UserInputIndication_signalUpdate (OOCTXT* pctxt, H245UserInputIndication_signalUpdate* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpPresent);
+
+   /* encode duration */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->duration, 1U, 65535U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rtp */
+
+   if (pvalue->m.rtpPresent) {
+      stat = asn1PE_H245UserInputIndication_signalUpdate_rtp (pctxt, &pvalue->rtp);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication_extendedAlphanumeric                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UserInputIndication_extendedAlphanumeric (OOCTXT* pctxt, H245UserInputIndication_extendedAlphanumeric* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpPayloadIndicationPresent);
+
+   /* encode alphanumeric */
+
+   stat = encodeVarWidthCharString (pctxt, pvalue->alphanumeric);
+   if (stat != ASN_OK) return stat;
+
+   /* encode rtpPayloadIndication */
+
+   if (pvalue->m.rtpPayloadIndicationPresent) {
+      /* NULL */
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  UserInputIndication                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245UserInputIndication (OOCTXT* pctxt, H245UserInputIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 2);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* 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)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* alphanumeric */
+         case 2:
+            stat = encodeVarWidthCharString (pctxt, pvalue->u.alphanumeric);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* userInputSupportIndication */
+         case 3:
+            stat = asn1PE_H245UserInputIndication_userInputSupportIndication (&lctxt, pvalue->u.userInputSupportIndication);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* signal */
+         case 4:
+            stat = asn1PE_H245UserInputIndication_signal (&lctxt, pvalue->u.signal);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* signalUpdate */
+         case 5:
+            stat = asn1PE_H245UserInputIndication_signalUpdate (&lctxt, pvalue->u.signalUpdate);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* extendedAlphanumeric */
+         case 6:
+            stat = asn1PE_H245UserInputIndication_extendedAlphanumeric (&lctxt, pvalue->u.extendedAlphanumeric);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  H2250MaximumSkewIndication                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245H2250MaximumSkewIndication (OOCTXT* pctxt, H245H2250MaximumSkewIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode logicalChannelNumber1 */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber1);
+   if (stat != ASN_OK) return stat;
+
+   /* encode logicalChannelNumber2 */
+
+   stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber2);
+   if (stat != ASN_OK) return stat;
+
+   /* encode maximumSkew */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->maximumSkew, 0U, 4095U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MCLocationIndication                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MCLocationIndication (OOCTXT* pctxt, H245MCLocationIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode signalAddress */
+
+   stat = asn1PE_H245TransportAddress (pctxt, &pvalue->signalAddress);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  TerminalYouAreSeeingInSubPictureNumber                    */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245TerminalYouAreSeeingInSubPictureNumber (OOCTXT* pctxt, H245TerminalYouAreSeeingInSubPictureNumber* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode terminalNumber */
+
+   stat = asn1PE_H245TerminalNumber (pctxt, pvalue->terminalNumber);
+   if (stat != ASN_OK) return stat;
+
+   /* encode subPictureNumber */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->subPictureNumber, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VideoIndicateCompose                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VideoIndicateCompose (OOCTXT* pctxt, H245VideoIndicateCompose* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode compositionNumber */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->compositionNumber, 0U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  ConferenceIndication                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245ConferenceIndication (OOCTXT* pctxt, H245ConferenceIndication* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 10);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* sbeNumber */
+         case 1:
+            stat = encodeConsUnsigned (pctxt, pvalue->u.sbeNumber, 0U, 9U);
+            if (stat != ASN_OK) return stat;
+
+            break;
+
+         /* terminalNumberAssign */
+         case 2:
+            stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.terminalNumberAssign);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* terminalJoinedConference */
+         case 3:
+            stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.terminalJoinedConference);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* terminalLeftConference */
+         case 4:
+            stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.terminalLeftConference);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* seenByAtLeastOneOther */
+         case 5:
+            /* NULL */
+            break;
+
+         /* cancelSeenByAtLeastOneOther */
+         case 6:
+            /* NULL */
+            break;
+
+         /* seenByAll */
+         case 7:
+            /* NULL */
+            break;
+
+         /* cancelSeenByAll */
+         case 8:
+            /* NULL */
+            break;
+
+         /* terminalYouAreSeeing */
+         case 9:
+            stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.terminalYouAreSeeing);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestForFloor */
+         case 10:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* withdrawChairToken */
+         case 11:
+            /* NULL */
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* floorRequested */
+         case 12:
+            stat = asn1PE_H245TerminalLabel (&lctxt, pvalue->u.floorRequested);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* terminalYouAreSeeingInSubPictureNumber */
+         case 13:
+            stat = asn1PE_H245TerminalYouAreSeeingInSubPictureNumber (&lctxt, pvalue->u.terminalYouAreSeeingInSubPictureNumber);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* videoIndicateCompose */
+         case 14:
+            stat = asn1PE_H245VideoIndicateCompose (&lctxt, pvalue->u.videoIndicateCompose);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification_productNumber                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VendorIdentification_productNumber (OOCTXT* pctxt, H245VendorIdentification_productNumber* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification_versionNumber                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VendorIdentification_versionNumber (OOCTXT* pctxt, H245VendorIdentification_versionNumber* pvalue)
+{
+   static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
+   int stat = ASN_OK;
+
+   addSizeConstraint (pctxt, &lsize1);
+
+   stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  VendorIdentification                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245VendorIdentification (OOCTXT* pctxt, H245VendorIdentification* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.productNumberPresent);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.versionNumberPresent);
+
+   /* encode vendor */
+
+   stat = asn1PE_H245NonStandardIdentifier (pctxt, &pvalue->vendor);
+   if (stat != ASN_OK) return stat;
+
+   /* encode productNumber */
+
+   if (pvalue->m.productNumberPresent) {
+      stat = asn1PE_H245VendorIdentification_productNumber (pctxt, &pvalue->productNumber);
+      if (stat != ASN_OK) return stat;
+   }
+
+   /* encode versionNumber */
+
+   if (pvalue->m.versionNumberPresent) {
+      stat = asn1PE_H245VendorIdentification_versionNumber (pctxt, &pvalue->versionNumber);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotSupported_cause                                */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FunctionNotSupported_cause (OOCTXT* pctxt, H245FunctionNotSupported_cause* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* syntaxError */
+         case 1:
+            /* NULL */
+            break;
+
+         /* semanticError */
+         case 2:
+            /* NULL */
+            break;
+
+         /* unknownFunction */
+         case 3:
+            /* NULL */
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FunctionNotSupported                                      */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FunctionNotSupported (OOCTXT* pctxt, H245FunctionNotSupported* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   encodeBit (pctxt, (ASN1BOOL)pvalue->m.returnedFunctionPresent);
+
+   /* encode cause */
+
+   stat = asn1PE_H245FunctionNotSupported_cause (pctxt, &pvalue->cause);
+   if (stat != ASN_OK) return stat;
+
+   /* encode returnedFunction */
+
+   if (pvalue->m.returnedFunctionPresent) {
+      stat = encodeOctetString (pctxt, pvalue->returnedFunction.numocts, pvalue->returnedFunction.data);
+      if (stat != ASN_OK) return stat;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication_crcDesired                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkIndication_crcDesired (OOCTXT* pctxt, H245MultilinkIndication_crcDesired* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication_excessiveError                        */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkIndication_excessiveError (OOCTXT* pctxt, H245MultilinkIndication_excessiveError* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode connectionIdentifier */
+
+   stat = asn1PE_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultilinkIndication                                       */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultilinkIndication (OOCTXT* pctxt, H245MultilinkIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 3);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* crcDesired */
+         case 2:
+            stat = asn1PE_H245MultilinkIndication_crcDesired (pctxt, pvalue->u.crcDesired);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* excessiveError */
+         case 3:
+            stat = asn1PE_H245MultilinkIndication_excessiveError (pctxt, pvalue->u.excessiveError);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  LogicalChannelRateRelease                                 */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245LogicalChannelRateRelease (OOCTXT* pctxt, H245LogicalChannelRateRelease* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication_scope                               */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FlowControlIndication_scope (OOCTXT* pctxt, H245FlowControlIndication_scope* pvalue)
+{
+   int stat = ASN_OK;
+
+   /* Encode choice index value */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
+   if (stat != ASN_OK) return stat;
+
+   /* Encode root element data value */
+
+   switch (pvalue->t)
+   {
+      /* logicalChannelNumber */
+      case 1:
+         stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelNumber);
+         if (stat != ASN_OK) return stat;
+         break;
+
+      /* resourceID */
+      case 2:
+         stat = encodeConsUnsigned (pctxt, pvalue->u.resourceID, 0U, 65535U);
+         if (stat != ASN_OK) return stat;
+
+         break;
+
+      /* wholeMultiplex */
+      case 3:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication_restriction                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FlowControlIndication_restriction (OOCTXT* pctxt, H245FlowControlIndication_restriction* 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)
+   {
+      /* maximumBitRate */
+      case 1:
+         stat = encodeConsUnsigned (pctxt, pvalue->u.maximumBitRate, 0U, 16777215U);
+         if (stat != ASN_OK) return stat;
+
+         break;
+
+      /* noRestriction */
+      case 2:
+         /* NULL */
+         break;
+
+      default:
+         return ASN_E_INVOPT;
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  FlowControlIndication                                     */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245FlowControlIndication (OOCTXT* pctxt, H245FlowControlIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode scope */
+
+   stat = asn1PE_H245FlowControlIndication_scope (pctxt, &pvalue->scope);
+   if (stat != ASN_OK) return stat;
+
+   /* encode restriction */
+
+   stat = asn1PE_H245FlowControlIndication_restriction (pctxt, &pvalue->restriction);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MobileMultilinkReconfigurationIndication                  */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MobileMultilinkReconfigurationIndication (OOCTXT* pctxt, H245MobileMultilinkReconfigurationIndication* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = 0;
+
+   encodeBit (pctxt, extbit);
+
+   /* encode sampleSize */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->sampleSize, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   /* encode samplesPerFrame */
+
+   stat = encodeConsUnsigned (pctxt, pvalue->samplesPerFrame, 1U, 255U);
+   if (stat != ASN_OK) return stat;
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  IndicationMessage                                         */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245IndicationMessage (OOCTXT* pctxt, H245IndicationMessage* pvalue)
+{
+   int stat = ASN_OK;
+   OOCTXT lctxt;
+   ASN1OpenType openType;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 14);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 13);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* nonStandard */
+         case 1:
+            stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* functionNotUnderstood */
+         case 2:
+            stat = asn1PE_H245FunctionNotUnderstood (pctxt, pvalue->u.functionNotUnderstood);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* masterSlaveDeterminationRelease */
+         case 3:
+            stat = asn1PE_H245MasterSlaveDeterminationRelease (pctxt, pvalue->u.masterSlaveDeterminationRelease);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* terminalCapabilitySetRelease */
+         case 4:
+            stat = asn1PE_H245TerminalCapabilitySetRelease (pctxt, pvalue->u.terminalCapabilitySetRelease);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* openLogicalChannelConfirm */
+         case 5:
+            stat = asn1PE_H245OpenLogicalChannelConfirm (pctxt, pvalue->u.openLogicalChannelConfirm);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestChannelCloseRelease */
+         case 6:
+            stat = asn1PE_H245RequestChannelCloseRelease (pctxt, pvalue->u.requestChannelCloseRelease);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* multiplexEntrySendRelease */
+         case 7:
+            stat = asn1PE_H245MultiplexEntrySendRelease (pctxt, pvalue->u.multiplexEntrySendRelease);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestMultiplexEntryRelease */
+         case 8:
+            stat = asn1PE_H245RequestMultiplexEntryRelease (pctxt, pvalue->u.requestMultiplexEntryRelease);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* requestModeRelease */
+         case 9:
+            stat = asn1PE_H245RequestModeRelease (pctxt, pvalue->u.requestModeRelease);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* miscellaneousIndication */
+         case 10:
+            stat = asn1PE_H245MiscellaneousIndication (pctxt, pvalue->u.miscellaneousIndication);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* jitterIndication */
+         case 11:
+            stat = asn1PE_H245JitterIndication (pctxt, pvalue->u.jitterIndication);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* h223SkewIndication */
+         case 12:
+            stat = asn1PE_H245H223SkewIndication (pctxt, pvalue->u.h223SkewIndication);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* newATMVCIndication */
+         case 13:
+            stat = asn1PE_H245NewATMVCIndication (pctxt, pvalue->u.newATMVCIndication);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* userInput */
+         case 14:
+            stat = asn1PE_H245UserInputIndication (pctxt, pvalue->u.userInput);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 15);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+      initContext (&lctxt);
+      stat = setPERBuffer (&lctxt, 0, 0, TRUE);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      switch (pvalue->t)
+      {
+         /* h2250MaximumSkewIndication */
+         case 15:
+            stat = asn1PE_H245H2250MaximumSkewIndication (&lctxt, pvalue->u.h2250MaximumSkewIndication);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* mcLocationIndication */
+         case 16:
+            stat = asn1PE_H245MCLocationIndication (&lctxt, pvalue->u.mcLocationIndication);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* conferenceIndication */
+         case 17:
+            stat = asn1PE_H245ConferenceIndication (&lctxt, pvalue->u.conferenceIndication);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* vendorIdentification */
+         case 18:
+            stat = asn1PE_H245VendorIdentification (&lctxt, pvalue->u.vendorIdentification);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* functionNotSupported */
+         case 19:
+            stat = asn1PE_H245FunctionNotSupported (&lctxt, pvalue->u.functionNotSupported);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* multilinkIndication */
+         case 20:
+            stat = asn1PE_H245MultilinkIndication (&lctxt, pvalue->u.multilinkIndication);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* logicalChannelRateRelease */
+         case 21:
+            stat = asn1PE_H245LogicalChannelRateRelease (&lctxt, pvalue->u.logicalChannelRateRelease);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* flowControlIndication */
+         case 22:
+            stat = asn1PE_H245FlowControlIndication (&lctxt, pvalue->u.flowControlIndication);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         /* mobileMultilinkReconfigurationIndication */
+         case 23:
+            stat = asn1PE_H245MobileMultilinkReconfigurationIndication (&lctxt, pvalue->u.mobileMultilinkReconfigurationIndication);
+            if (stat != ASN_OK) return freeContext (&lctxt), stat;
+            openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
+            break;
+
+         default:
+            ;
+      }
+
+      stat = encodeByteAlign (pctxt);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      stat = encodeOpenType (pctxt, openType.numocts, openType.data);
+      if (stat != ASN_OK) return freeContext (&lctxt), stat;
+
+      freeContext (&lctxt);
+   }
+
+   return (stat);
+}
+
+/**************************************************************/
+/*                                                            */
+/*  MultimediaSystemControlMessage                            */
+/*                                                            */
+/**************************************************************/
+
+EXTERN int asn1PE_H245MultimediaSystemControlMessage (OOCTXT* pctxt, H245MultimediaSystemControlMessage* pvalue)
+{
+   int stat = ASN_OK;
+   ASN1BOOL extbit;
+
+   /* extension bit */
+
+   extbit = (ASN1BOOL)(pvalue->t > 4);
+
+   encodeBit (pctxt, extbit);
+
+   if (!extbit) {
+
+      /* Encode choice index value */
+
+      stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode root element data value */
+
+      switch (pvalue->t)
+      {
+         /* request */
+         case 1:
+            stat = asn1PE_H245RequestMessage (pctxt, pvalue->u.request);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* response */
+         case 2:
+            stat = asn1PE_H245ResponseMessage (pctxt, pvalue->u.response);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* command */
+         case 3:
+            stat = asn1PE_H245CommandMessage (pctxt, pvalue->u.command);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         /* indication */
+         case 4:
+            stat = asn1PE_H245IndicationMessage (pctxt, pvalue->u.indication);
+            if (stat != ASN_OK) return stat;
+            break;
+
+         default:
+            return ASN_E_INVOPT;
+      }
+   }
+   else {
+      /* Encode extension choice index value */
+
+      stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
+      if (stat != ASN_OK) return stat;
+
+      /* Encode extension element data value */
+
+   }
+
+   return (stat);
+}
+
diff --git a/addons/ooh323c/src/memheap.c b/addons/ooh323c/src/memheap.c
new file mode 100644
index 000000000..48040a7ef
--- /dev/null
+++ b/addons/ooh323c/src/memheap.c
@@ -0,0 +1,1331 @@
+/*
+ * Copyright (C) 1997-2004 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the LICENSE.txt file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include <stdlib.h>
+#include "memheap.h"
+
+ASN1UINT      g_defBlkSize = XM_K_MEMBLKSIZ;
+OSMallocFunc  g_malloc_func = malloc;
+#ifndef _NO_REALLOC
+OSReallocFunc g_realloc_func = realloc;
+#else
+OSReallocFunc g_realloc_func = 0;
+#endif
+OSFreeFunc    g_free_func = free;
+
+static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, 
+                                   void* pMemBlk, int blockType);
+
+typedef void OSMemElemDescr;
+
+
+#define pElem_flags(pElem)       (*((ASN1OCTET*)pElem))
+#define pElem_nunits(pElem)      (*((ASN1USINT*)(((ASN1OCTET*)pElem)+2)))
+#define pElem_prevOff(pElem)     (*((ASN1USINT*)(((ASN1OCTET*)pElem)+4)))
+#define pElem_nextFreeOff(pElem) (*((ASN1USINT*)(((ASN1OCTET*)pElem)+6)))
+#define pElem_beginOff(pElem)    (*((ASN1USINT*)(((ASN1OCTET*)pElem)+6)))
+#define sizeof_OSMemElemDescr    8
+#define pElem_data(pElem)        (((ASN1OCTET*)pElem)+sizeof_OSMemElemDescr)
+
+typedef struct MemBlk {
+   OSMemLink*      plink;
+   ASN1USINT       free_x;      /* index of free space at end of block */
+   ASN1USINT       freeMem;     /* size of free space before free_x    */
+   ASN1USINT       nunits;      /* size of data                        */
+   ASN1USINT       lastElemOff; /* last element offset in block        */
+   ASN1USINT       freeElemOff; /* first free element offset in block  */
+   ASN1USINT       nsaved;      /* num of saved elems in the block     */
+
+   ASN1USINT       spare[2];    /* forces alignment on 8-bytes boundary,
+                                   for 64-bit systems */
+   char            data[8];
+} OSMemBlk;
+
+/* Macros for operations with memory blocks */
+
+#define QOFFSETOF(pElem, pPrevElem) \
+((ASN1USINT)(((unsigned)((char*)pElem - (char*)pPrevElem)) >> 3u))
+
+#define OFFSETOF(pElem, pPrevElem) \
+((ASN1UINT)((char*)pElem - (char*)pPrevElem))
+
+#define ISFREE(pElem)      (pElem_flags(pElem) & 1)
+#define SET_FREE(pElem)    (pElem_flags(pElem) |= 1)
+#define CLEAR_FREE(pElem)  (pElem_flags(pElem) &= (~1))
+
+#define ISLAST(pElem)      (pElem_flags(pElem) & 2)
+#define SET_LAST(pElem)    (pElem_flags(pElem) |= 2)
+#define CLEAR_LAST(pElem)  (pElem_flags(pElem) &= (~2))
+
+#define ISSAVED(pElem)      (pElem_flags(pElem) & 4)
+#define SET_SAVED(pMemBlk,pElem)    do { \
+(pElem_flags (pElem) |= 4); pMemBlk->nsaved++; } while (0)
+#define CLEAR_SAVED(pMemBlk,pElem)  do { \
+(pElem_flags (pElem) &= (~4)); pMemBlk->nsaved--; } while (0)
+
+#define ISFIRST(pElem)    (int)(pElem_prevOff (pElem) == 0)
+
+#define GETPREV(pElem) \
+((pElem_prevOff (pElem) == 0) ? 0 : \
+((OSMemElemDescr*) (((char*)pElem) - (pElem_prevOff (pElem) * 8u))))
+
+#define GETNEXT(pElem) \
+((ISLAST (pElem)) ? 0 : \
+((OSMemElemDescr*)(((char*)pElem) + ((pElem_nunits (pElem) + 1) * 8u))))
+
+#define GET_NEXT_FREE(pElem) \
+((pElem_nextFreeOff (pElem) == 0) ? 0 : \
+((OSMemElemDescr*) (((char*)pElem) + (pElem_nextFreeOff (pElem) * 8u))))
+
+#define GET_MEMBLK(pElem) \
+((OSMemBlk*) (((char*)pElem) - (pElem_beginOff (pElem) * 8u) - \
+sizeof (OSMemBlk) + sizeof ((OSMemBlk*)0)->data))
+
+#define GET_LAST_ELEM(pMemBlk) \
+((pMemBlk->lastElemOff == 0) ? 0 : \
+(OSMemElemDescr*)&pMemBlk->data[(pMemBlk->lastElemOff - 1) * 8u])
+
+#define SET_LAST_ELEM(pMemBlk, pElem) \
+pMemBlk->lastElemOff = (ASN1USINT)((pElem == 0) ? 0 : \
+(SET_LAST (pElem), (QOFFSETOF (pElem, pMemBlk->data) + 1)))
+
+#define GET_FREE_ELEM(pMemBlk) \
+((pMemBlk->freeElemOff == 0) ? 0 : \
+(OSMemElemDescr*)&pMemBlk->data[(pMemBlk->freeElemOff - 1) * 8u])
+
+#define FORCE_SET_FREE_ELEM(pMemBlk, pElem) do { \
+if (pElem == 0) { pMemBlk->freeElemOff = 0; break; } \
+SET_FREE (pElem); \
+pMemBlk->freeElemOff = (ASN1USINT)(QOFFSETOF (pElem, pMemBlk->data) + 1); \
+} while (0)
+
+#define SET_FREE_ELEM(pMemBlk, pElem) setLastElem (pMemBlk, pElem)
+
+/* Memory debugging macros */
+#define RTMEMDIAG1(msg)       
+#define RTMEMDIAG2(msg,a)  
+#define RTMEMDIAG3(msg,a,b)
+#define RTMEMDIAG4(msg,a,b,c)
+#define FILLFREEMEM(mem,size)
+#define FILLNEWMEM(mem,size) 
+
+#define CHECKMEMELEM(memblk,elem)
+#define CHECKMEMBLOCK(memheap,memblk)
+#define CHECKMEMHEAP(memheap) 
+#define TRACEMEMELEM(memblk, elem, name)
+#define TRACEFREE(memlink,name)
+
+
+static void setLastElem (OSMemBlk* pMemBlk, OSMemElemDescr* pElem) 
+{
+   if (pElem == 0) { 
+      pMemBlk->freeElemOff = 0; 
+      return; 
+   }
+   else if (ISLAST (pElem)) 
+      return; 
+   else if (pMemBlk->freeElemOff > QOFFSETOF (pElem, pMemBlk->data) + 1) {
+      pElem_nextFreeOff (pElem) = QOFFSETOF (GET_FREE_ELEM (pMemBlk), pElem); 
+      FORCE_SET_FREE_ELEM (pMemBlk, pElem); 
+   } 
+   else if (pMemBlk->freeElemOff == 0) { 
+      pElem_nextFreeOff (pElem) = 0;          
+      FORCE_SET_FREE_ELEM (pMemBlk, pElem); 
+   } 
+   else { 
+      SET_FREE (pElem); 
+      pElem_nextFreeOff (pElem) = 0; 
+   }
+}
+
+void* memHeapAlloc (void** ppvMemHeap, int nbytes)
+{
+   OSMemHeap* pMemHeap;
+   OSMemLink* pMemLink, **ppMemLink;
+   OSMemBlk*  pMemBlk = 0;
+   void* mem_p = NULL;
+   unsigned remUnits;
+   ASN1UINT nunits;
+
+   if (ppvMemHeap == 0)
+      return 0;
+
+   if (*ppvMemHeap == 0)
+      if (memHeapCreate (ppvMemHeap) != ASN_OK)
+         return 0;
+
+   /* Round number of bytes to nearest 8-byte boundary */
+
+   nunits = (((unsigned)(nbytes + 7)) >> 3);
+
+   pMemHeap = (OSMemHeap*) *ppvMemHeap;
+   ppMemLink = &pMemHeap->phead;
+
+   /* if size is greater than 2**19, then allocate as RAW block */
+   
+   if (nunits > (1<<16) - 2) {
+      void *data;
+
+      /* allocate raw block */
+
+      data = g_malloc_func (nbytes);
+      if (data == NULL) {
+         return NULL;
+      }
+      pMemLink = memHeapAddBlock (ppMemLink, data, RTMEMMALLOC | RTMEMRAW);
+      if (pMemLink == 0) {
+         g_free_func (data);
+         return NULL;
+      }
+      /* save size of the RAW memory block behind the pMemLink */
+      *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes;
+      return data;   
+   }
+   
+   RTMEMDIAG2 ("memHeapAlloc: adjusted nbytes = %d\n", nbytes);
+
+   /* Try to allocate a slot from an existing block on the list */
+
+   for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnext) {
+      if (pMemLink->blockType & RTMEMRAW) continue;
+      else pMemBlk = (OSMemBlk*) pMemLink->pMemBlk;
+
+      remUnits = pMemBlk->nunits - pMemBlk->free_x;
+
+      if ((unsigned)(nunits + 1) <= remUnits) {
+         OSMemElemDescr* pElem = (OSMemElemDescr*)
+            &pMemBlk->data [((ASN1UINT)pMemBlk->free_x) * 8u];
+         OSMemElemDescr* pPrevElem;
+
+         RTMEMDIAG1 ("memHeapAlloc: found existing slot..\n");
+
+         /* if block is clean, set some vars in heap */
+         if (pMemBlk->free_x == 0) {
+            pMemHeap->freeUnits -= pMemBlk->nunits;
+            pMemHeap->freeBlocks--;
+         }
+
+         pElem_flags (pElem) = 0;
+         if (pMemBlk->lastElemOff != 0)
+            pElem_prevOff (pElem) = 
+               (ASN1USINT)(pMemBlk->free_x - pMemBlk->lastElemOff + 1);
+         else 
+            pElem_prevOff (pElem) = 0;
+         
+         pPrevElem = GET_LAST_ELEM (pMemBlk);
+         if (pPrevElem != 0)
+            CLEAR_LAST (pPrevElem);
+         
+         pElem_nunits (pElem) = (ASN1USINT)nunits; 
+         pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data);
+         pMemBlk->lastElemOff = (ASN1USINT)(pMemBlk->free_x + 1);
+
+         mem_p = (void*) (pElem_data (pElem));
+         
+         /* sizeof (OSMemElemDescr) == 1 unit */
+         pMemBlk->free_x += nunits + 1; 
+         
+         SET_LAST_ELEM (pMemBlk, pElem);
+         
+         FILLNEWMEM (mem_p, nunits * 8u);
+         TRACEMEMELEM(pMemBlk, pElem, "Allocated");
+         CHECKMEMELEM (pMemBlk, pElem);
+         CHECKMEMBLOCK (pMemHeap, pMemBlk);
+         break;
+      }
+   }
+
+   /* If not successful, look for empty elements in existing blocks */
+
+   if (0 == mem_p) {
+      for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnext) {
+         if (pMemLink->blockType & RTMEMRAW) continue;
+         
+         pMemBlk = (OSMemBlk*) pMemLink->pMemBlk;
+
+         if (nunits <= (ASN1UINT)pMemBlk->freeMem) {
+            OSMemElemDescr* pElem = GET_FREE_ELEM(pMemBlk), *pPrevFree = 0;
+
+            RTMEMDIAG2 
+           ("memHeapAlloc: try to reuse empty elems in pMemBlk = 0x%x...\n", 
+                pMemBlk);
+
+            while (pElem != 0) {
+               if (ISFREE (pElem)) { 
+                  if (nunits <= (ASN1UINT)pElem_nunits (pElem)) {
+                     RTMEMDIAG3 
+                        ("memHeapAlloc: "
+                         "found an exisiting free element 0x%x, size %d\n", 
+                        pElem, (pElem_nunits (pElem) * 8u));
+                     
+                     if (pMemBlk->freeElemOff == 
+                         QOFFSETOF (pElem, pMemBlk->data) + 1) 
+                     {
+                        
+                        /* modify the pMemBlk->freeElemOff value if necsry */
+
+                        OSMemElemDescr* nextFree = GET_NEXT_FREE (pElem);
+                        FORCE_SET_FREE_ELEM (pMemBlk, nextFree); 
+                     }
+                     else if (pPrevFree != 0) {
+                        OSMemElemDescr* pNextFree = GET_NEXT_FREE (pElem);
+                        if (pNextFree != 0)
+                           pElem_nextFreeOff (pPrevFree) = QOFFSETOF (pNextFree, 
+                              pPrevFree);
+                        else
+                           pElem_nextFreeOff (pPrevFree) = 0;
+                     } 
+
+                     CLEAR_FREE (pElem);
+
+                     /* set beginOff value */
+
+                     pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data);
+                     
+                     pMemBlk->freeMem -= pElem_nunits (pElem);
+
+                     CHECKMEMELEM (pMemBlk, pElem);
+                     CHECKMEMBLOCK (pMemHeap, pMemBlk);
+                     
+                     mem_p = memHeapRealloc 
+                        (ppvMemHeap, pElem_data (pElem), nunits * 8u);
+                     if (mem_p != 0) {
+                        FILLNEWMEM (mem_p, nunits * 8u);
+                        TRACEMEMELEM(pMemBlk, pElem, "Allocated");
+                     }
+                     break;
+                  }
+               }
+               pPrevFree = pElem;
+               pElem = GET_NEXT_FREE (pElem);
+            }
+            if (mem_p != 0) break;
+         }
+      }   
+   }
+
+   /* If not successful, malloc a new block and alloc from it */
+
+   if (!mem_p) {
+      ASN1UINT allocSize, dataUnits;
+      ASN1OCTET* pmem;
+      register ASN1UINT defBlkSize = pMemHeap->defBlkSize;
+
+      RTMEMDIAG1 ("memHeapAlloc: alloc block..\n");
+
+      allocSize = (ASN1UINT) ((((ASN1UINT)nunits) * 8u) + 
+         sizeof (OSMemBlk) + sizeof_OSMemElemDescr);
+      allocSize = (ASN1UINT) (allocSize < defBlkSize) ? defBlkSize : 
+         ((allocSize + defBlkSize - 1) / defBlkSize * defBlkSize);
+      dataUnits = (ASN1UINT)((allocSize - sizeof (OSMemBlk)) >> 3u);
+      if (dataUnits >= (1u<<16)) {
+         dataUnits = (ASN1UINT)((1u<<16) - 1);
+         allocSize = (ASN1UINT)
+            ((((ASN1UINT)dataUnits) * 8u) + sizeof (OSMemBlk));
+      }  
+
+      pmem = (ASN1OCTET*) g_malloc_func (allocSize + sizeof (OSMemLink));
+      if (0 != pmem) {
+         OSMemElemDescr* pElem;
+
+         pMemBlk = (OSMemBlk*) (pmem + sizeof (OSMemLink));
+         pElem = (OSMemElemDescr*)&pMemBlk->data[0];
+
+         mem_p = (void*) pElem_data (pElem);
+         pElem_nunits (pElem) = (ASN1USINT)nunits;
+         pElem_flags (pElem) = 0;
+         pElem_prevOff (pElem) = 0;
+         pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data);
+
+         /* sizeof (OSMemElemDescr) == 1 unit */
+         pMemBlk->free_x = (ASN1USINT)(nunits + 1); 
+
+         pMemBlk->freeMem = 0;
+         pMemBlk->nunits = (ASN1USINT)dataUnits;
+         SET_LAST_ELEM (pMemBlk, pElem);
+         pMemBlk->freeElemOff = 0;
+         pMemBlk->nsaved = 0;
+
+         if (memHeapAddBlock (ppMemLink, pMemBlk, RTMEMSTD | RTMEMLINK) == 0) 
+         {
+            g_free_func (pmem);
+            return NULL;
+         }
+
+         /* set vars in heap */
+         pMemHeap->usedUnits += dataUnits;
+         pMemHeap->usedBlocks++;
+
+         FILLNEWMEM (mem_p, nunits * 8u);
+         TRACEMEMELEM(pMemBlk, pElem, "Allocated");
+         CHECKMEMELEM (pMemBlk, pElem);
+         CHECKMEMBLOCK (pMemHeap, pMemBlk);
+      }
+      else 
+         return NULL;
+   }
+   RTMEMDIAG2 ("memHeapAlloc: pMemBlk = 0x%x\n", pMemBlk);
+   RTMEMDIAG2 ("memHeapAlloc: pMemBlk->free_x = %d\n", pMemBlk->free_x);
+   RTMEMDIAG2 ("memHeapAlloc: pMemBlk->size = %d\n", 
+                    pMemBlk->nunits * 8u);
+   RTMEMDIAG2 ("memHeapAlloc: mem_p = 0x%x\n", mem_p);
+   RTMEMDIAG2 ("memHeapAlloc: sizeof (short) = %d\n", sizeof(short));
+
+   return (mem_p);
+}
+
+void* memHeapAllocZ (void** ppvMemHeap, int nbytes)
+{
+   void* ptr = memHeapAlloc (ppvMemHeap, nbytes);
+   if (0 != ptr) memset (ptr, 0, nbytes);
+   return ptr;
+}
+
+void memHeapFreePtr (void** ppvMemHeap, void* mem_p) 
+{
+   OSMemHeap* pMemHeap;
+   OSMemLink** ppMemLink;
+   OSMemElemDescr* pElem;
+   OSMemBlk* pMemBlk;
+   OSMemLink* pMemLink, *pPrevMemLink = 0;
+
+   RTMEMDIAG2 ("memHeapFreePtr: freeing mem_p = 0x%x\n", mem_p);
+
+   if (mem_p == 0 || ppvMemHeap == 0 || *ppvMemHeap == 0) return;
+
+   pMemHeap = *(OSMemHeap**)ppvMemHeap;
+   ppMemLink = &pMemHeap->phead;
+
+   /* look for chain of RAW blocks first */
+
+   for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnextRaw) {
+      if ((pMemLink->blockType & RTMEMRAW) &&
+           pMemLink->pMemBlk == mem_p) 
+      {
+         if(pMemLink->pnext != 0) {
+            pMemLink->pnext->pprev = pMemLink->pprev;
+         }
+         if(pMemLink->pprev != 0) {
+            pMemLink->pprev->pnext = pMemLink->pnext;
+         }
+         else { /* head */
+            *ppMemLink = pMemLink->pnext;
+         }
+         if (pPrevMemLink != 0)
+            pPrevMemLink->pnextRaw = pMemLink->pnextRaw;
+         else if (*ppMemLink != 0 && (*ppMemLink)->pnextRaw == 0 && 
+            *ppMemLink != pMemLink->pnextRaw)
+         {
+            (*ppMemLink)->pnextRaw = pMemLink->pnextRaw;
+         }
+         if ((pMemLink->blockType & RTMEMLINK) && 
+             (pMemLink->blockType & RTMEMMALLOC))
+         {
+            g_free_func (pMemLink);
+         }
+         else {
+            if (pMemLink->blockType & RTMEMMALLOC)
+               g_free_func (pMemLink->pMemBlk);
+            g_free_func (pMemLink);
+         }
+         return;
+      }
+      pPrevMemLink = pMemLink;
+   }
+
+   pElem = (OSMemElemDescr*) (((char*)mem_p) - sizeof_OSMemElemDescr);
+   pMemBlk = GET_MEMBLK (pElem);
+
+   CHECKMEMELEM (pMemBlk, pElem);
+   CHECKMEMBLOCK(pMemHeap, pMemBlk);
+
+   if (ISFREE (pElem)) { /* already freed! */
+      RTMEMDIAG2 ("memHeapFreePtr: "
+                      "the element 0x%x is already freed!\n", pElem);
+      return;   
+   }
+
+   if (ISSAVED (pElem)) {
+      CLEAR_SAVED (pMemBlk, pElem);
+      if (pMemBlk->nsaved == 0)
+         pMemBlk->plink->blockType &= (~RTMEMSAVED);
+   }
+
+   TRACEMEMELEM(pMemBlk, pElem, "Freed");
+   CHECKMEMELEM (pMemBlk, pElem);
+   CHECKMEMBLOCK(pMemHeap, pMemBlk);
+
+   RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x\n", pMemBlk);
+   RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->size = %d\n", 
+                    pMemBlk->nunits * 8u);
+
+   if (ISLAST (pElem)) { /* is it the last? */
+      OSMemElemDescr* pPrevElem = GETPREV (pElem);
+      
+      CHECKMEMELEM (pMemBlk, pPrevElem);
+
+      pMemBlk->free_x -= (pElem_nunits (pElem) + 1);
+
+      FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u], 
+         (pElem_nunits (pElem) + 1) * 8u);
+
+      if (pPrevElem != 0 && ISFREE (pPrevElem)) {
+         OSMemElemDescr* pFreeElem;
+
+         pMemBlk->free_x -= (pElem_nunits (pPrevElem) + 1);
+         pMemBlk->freeMem -= pElem_nunits (pPrevElem);
+         SET_LAST_ELEM (pMemBlk, GETPREV (pPrevElem));
+         
+         /* wasn't it the last elem in block? */
+         if (pMemBlk->lastElemOff != 0) { 
+            
+            /* correct nextFreeOff for previous free element */
+
+            pFreeElem = GET_FREE_ELEM (pMemBlk);
+            if (pFreeElem == pPrevElem) {
+               pMemBlk->freeElemOff = 0; /* it was the last free elem */
+            }
+            else {
+               OSMemElemDescr* pNextFree = 0;
+               
+               while (pFreeElem < pPrevElem) {
+                  pNextFree = pFreeElem;
+                  pFreeElem = GET_NEXT_FREE (pFreeElem);
+               }
+               pElem_nextFreeOff (pNextFree) = 0;
+            }
+         }
+      }
+      else {
+         SET_LAST_ELEM (pMemBlk, pPrevElem);
+      }
+
+      RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->free_x = %d\n", 
+                       pMemBlk->free_x);
+
+      /* The question is: do we really want to get rid of the   */
+      /* block or should we keep it around for reuse?           */
+      if (pMemBlk->lastElemOff == 0) { /* was it the last elem in block? */
+         
+         if ((pMemHeap->flags & RT_MH_DONTKEEPFREE) ||
+             (pMemHeap->keepFreeUnits > 0 && 
+              pMemHeap->freeUnits + pMemBlk->nunits > pMemHeap->keepFreeUnits))
+         {
+            ASN1OCTET blockType = pMemBlk->plink->blockType;
+
+            /* we may free the block */
+
+            pMemHeap->usedUnits -= pMemBlk->nunits;
+            pMemHeap->usedBlocks --;
+
+            if(pMemBlk->plink->pnext != 0) {
+               pMemBlk->plink->pnext->pprev = pMemBlk->plink->pprev;
+            }
+            if(pMemBlk->plink->pprev != 0) {
+               pMemBlk->plink->pprev->pnext = pMemBlk->plink->pnext;
+            }
+            else { /* head */
+               if (pMemBlk->plink->pnext != 0 && 
+                   !(pMemBlk->plink->pnext->blockType & RTMEMRAW))
+               {
+                  pMemBlk->plink->pnext->pnextRaw = (*ppMemLink)->pnextRaw;
+               }
+               *ppMemLink = pMemBlk->plink->pnext;
+            }
+            FILLFREEMEM (pMemBlk->plink, sizeof (*pMemBlk->plink));
+            FILLFREEMEM (pMemBlk->data, (pMemBlk->nunits * 8u));
+         
+            g_free_func (pMemBlk->plink);
+            
+            if (!(blockType & RTMEMLINK)) {
+               FILLFREEMEM (pMemBlk, sizeof (*pMemBlk));
+               g_free_func (pMemBlk);
+            }
+            RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x was freed\n", 
+                             pMemBlk);
+         }
+         else {
+            /* reset pMemBlk for re-usage */
+            pMemBlk->free_x = 0;
+            pMemBlk->freeElemOff = 0;
+            pMemBlk->lastElemOff = 0;
+            pMemBlk->freeMem = 0;
+            pMemBlk->nsaved = 0;
+            pMemHeap->freeUnits += pMemBlk->nunits;
+            pMemHeap->freeBlocks ++;
+         }
+      }
+      else {
+         SET_LAST (GET_LAST_ELEM (pMemBlk));
+         FILLFREEMEM (((char*) &pMemBlk->data[0]) + (pMemBlk->free_x * 8u), 
+                      (pMemBlk->nunits - pMemBlk->free_x) * 8u);
+         CHECKMEMBLOCK (pMemHeap, pMemBlk);
+      }
+   }
+   else { /* mark as free elem inside the block */
+      CHECKMEMBLOCK (pMemHeap, pMemBlk);
+
+      SET_FREE_ELEM(pMemBlk, pElem);
+
+      pMemBlk->freeMem += pElem_nunits (pElem);
+      RTMEMDIAG2 ("memHeapFreePtr: element 0x%x marked as free.\n", 
+                       pElem);
+
+      /* try to unite free blocks, if possible */
+      if (!ISFIRST (pElem)) {
+         if (ISFREE (GETPREV (pElem))) {
+            OSMemElemDescr* prevelem_p = GETPREV (pElem);
+         
+            /* +1 because the OSMemElemDescr has size ONE unit (8 bytes) */
+            pElem_nunits (prevelem_p) += pElem_nunits (pElem) + 1; 
+
+            pElem = prevelem_p;
+            pMemBlk->freeMem ++; /* sizeof (OSMemElemDescr) == 1 unit */
+         }
+         else {
+            /* look for nearest previous free block to correct nextFreeOff */
+         
+            OSMemElemDescr* prevelem_p = pElem;
+         
+            do {
+               prevelem_p = GETPREV (prevelem_p);
+            }
+            while (prevelem_p && !ISFREE (prevelem_p));
+
+            if (prevelem_p != 0) {
+               OSMemElemDescr* pNextFree =  GET_NEXT_FREE (prevelem_p);
+               if (pNextFree != 0) 
+                  pElem_nextFreeOff (pElem) = QOFFSETOF (pNextFree, pElem);
+               else
+                  pElem_nextFreeOff (pElem) = 0;
+               pElem_nextFreeOff (prevelem_p) = QOFFSETOF (pElem, prevelem_p);
+         
+               CHECKMEMELEM (pMemBlk, prevelem_p);
+            }
+         }
+      }
+      if (!ISLAST (pElem) && ISFREE (GETNEXT (pElem))) {
+         OSMemElemDescr* nextelem_p = GETNEXT (pElem);
+         
+         /* +1 because the OSMemElemDescr has size ONE unit (8 bytes) */
+         pElem_nunits (pElem) += pElem_nunits (nextelem_p) + 1; 
+
+         if (pElem_nextFreeOff (nextelem_p) == 0)
+            pElem_nextFreeOff (pElem) = 0;
+         else
+            pElem_nextFreeOff (pElem) = 
+               QOFFSETOF (GET_NEXT_FREE (nextelem_p), pElem);
+         pMemBlk->freeMem ++;
+      }
+
+      /* correct the prevOff field of next element */
+      if (!ISLAST (pElem)) {  
+         OSMemElemDescr* nextelem_p = GETNEXT (pElem);
+         pElem_prevOff (nextelem_p) = QOFFSETOF (nextelem_p, pElem);
+      }
+
+      CHECKMEMELEM (pMemBlk, pElem);
+      FILLFREEMEM (pElem_data (pElem), (pElem_nunits (pElem) * 8u));
+      CHECKMEMELEM (pMemBlk, pElem);
+      CHECKMEMBLOCK (pMemHeap, pMemBlk);
+   }
+} 
+
+static void initNewFreeElement (OSMemBlk* pMemBlk, 
+   OSMemElemDescr* pNewElem, OSMemElemDescr* pElem) 
+{
+   OSMemElemDescr *pNextElem, *pPrevElem = 0;
+
+   /* create new free element on the freed place */
+
+   pElem_flags (pNewElem) = 0;
+   SET_FREE (pNewElem);
+
+   pElem_prevOff (pNewElem) = QOFFSETOF (pNewElem, pElem);
+
+   if (pMemBlk->freeElemOff != 0 && 
+      pMemBlk->freeElemOff < QOFFSETOF (pElem, pMemBlk->data) + 1)
+   {
+      /* look for nearest previous free block to correct its nextFreeOff */
+      
+      pPrevElem = pElem;
+
+      do {
+         pPrevElem = GETPREV (pPrevElem);
+      }
+      while (pPrevElem && !ISFREE (pPrevElem));
+   }
+   if (pPrevElem != 0) { /* if it is not first free element... */
+
+      /* correct nextFreeOff for prev free element */
+      
+      pElem_nextFreeOff (pPrevElem) = QOFFSETOF (pNewElem, pPrevElem);
+   }
+   else {  /* if it is first free element in the block */
+      FORCE_SET_FREE_ELEM (pMemBlk, pNewElem);
+   }
+   
+   pNextElem = GETNEXT (pNewElem);
+   if (ISFREE (pNextElem)) {
+      
+      /* if the next elem is free, then unite them together */
+
+      pElem_nunits (pNewElem) += pElem_nunits (pNextElem) + 1;
+      if (pElem_nextFreeOff (pNextElem) != 0)
+         pElem_nextFreeOff (pNewElem) = QOFFSETOF (GET_NEXT_FREE (pNextElem), 
+            pNewElem);
+      else
+         pElem_nextFreeOff (pNewElem) = 0;
+      pMemBlk->freeMem++; /* +1 because space for MemElemDescr is freed now */
+      pNextElem = GETNEXT (pNewElem);
+   }
+   pElem_prevOff (pNextElem) = QOFFSETOF (pNextElem, pNewElem);
+
+   if (pMemBlk->freeElemOff != 0) {
+
+      /* look for the next nearest free elem */
+
+      pNextElem = GETNEXT (pNewElem);
+      while (pNextElem != 0 && !ISFREE (pNextElem))
+         pNextElem = GETNEXT (pNextElem);
+
+      /* set nextFreeOff for new element */
+   
+      if (pNextElem != 0)
+         pElem_nextFreeOff (pNewElem) = QOFFSETOF (pNextElem, pNewElem);
+      else
+         pElem_nextFreeOff (pNewElem) = 0;
+   }
+   else
+      pElem_nextFreeOff (pNewElem) = 0;
+
+}
+
+void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
+{
+   OSMemHeap* pMemHeap;
+   OSMemLink** ppMemLink;
+   OSMemBlk* pMemBlk;
+   OSMemElemDescr* pElem;
+   OSMemLink* pMemLink, *pPrevMemLink = 0;
+   void *newMem_p;
+   unsigned nbytes, nunits;
+
+   /* if mem_p == NULL - do rtMemAlloc */
+
+   if (ppvMemHeap == 0 || *ppvMemHeap == 0) return 0;
+
+   if (mem_p == 0) {
+      return memHeapAlloc (ppvMemHeap, nbytes_);
+   }
+
+   pMemHeap = *(OSMemHeap**)ppvMemHeap;
+   ppMemLink = &pMemHeap->phead;
+
+   /* look for chain of RAW blocks first */
+
+   for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnextRaw) {
+      if ((pMemLink->blockType & RTMEMRAW) &&
+           pMemLink->pMemBlk == mem_p) 
+      {
+         if (pMemLink->blockType & RTMEMMALLOC)
+            if (g_realloc_func != 0) {
+               void *newMemBlk = g_realloc_func (pMemLink->pMemBlk, nbytes_);
+               if (newMemBlk == 0) 
+                  return 0;
+               pMemLink->pMemBlk = newMemBlk;
+            }
+            else {
+               /* use malloc/memcpy/free sequence instead of realloc */
+               ASN1OCTET* newBuf;
+               int oldSize = *(int*)(((char*)pMemLink) + sizeof (OSMemLink));
+
+               if (oldSize == -1) return 0;
+               newBuf = (ASN1OCTET*)g_malloc_func (nbytes_);
+               if (newBuf == 0)
+                  return 0;
+               memcpy (newBuf, pMemLink->pMemBlk, ASN1MIN (oldSize, nbytes_));
+               free (pMemLink->pMemBlk);
+               pMemLink->pMemBlk = newBuf;
+            }
+         else 
+            return 0;
+         *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes_;
+         return pMemLink->pMemBlk;
+      }
+      pPrevMemLink = pMemLink;
+   }
+
+   /* Round number of bytes to nearest 8-byte boundary */
+
+   nbytes = ((unsigned)(nbytes_ + 7)) & (~7);
+   nunits = nbytes >> 3;
+
+   pElem = (OSMemElemDescr*) (((char*)mem_p) - sizeof_OSMemElemDescr);
+
+   RTMEMDIAG3 ("memHeapRealloc: mem_p = 0x%x, old size = %d,",  mem_p, 
+                    pElem_nunits (pElem) * 8u);
+   RTMEMDIAG2 (" new nbytes = %d\n", nbytes);
+
+   if ((unsigned)pElem_nunits (pElem) == nunits)
+      return mem_p;
+
+   pMemBlk = GET_MEMBLK (pElem);
+
+   CHECKMEMELEM (pMemBlk, pElem);
+   CHECKMEMBLOCK(pMemHeap, pMemBlk);
+
+   if ((unsigned)pElem_nunits (pElem) < nunits) { /* expanding */
+   
+      if (nunits - pElem_nunits (pElem) <= (unsigned)pMemBlk->nunits) {
+
+         /* Try to expand the existing element in the existing block */
+
+         if (ISLAST (pElem)) { /* if the last element in the block */
+         
+            /* if the free space in the block is enough */
+         
+            if ((int)(nunits - pElem_nunits (pElem)) <= 
+                (int)(pMemBlk->nunits - pMemBlk->free_x)) 
+            { 
+               pMemBlk->free_x += nunits - pElem_nunits (pElem);
+               pElem_nunits (pElem) = (ASN1USINT)nunits;
+
+               RTMEMDIAG1 ("memHeapRealloc: "
+                               "memory element is expanded.\n");
+               
+               FILLNEWMEM (&pMemBlk->data [(pMemBlk->free_x - 
+                  (nunits - pElem_nunits (pElem))) * 8u], 
+                  (nunits - pElem_nunits (pElem)) * 8u);
+               
+               TRACEMEMELEM (pMemBlk, pElem, "Reallocated");
+               CHECKMEMELEM (pMemBlk, pElem);
+               CHECKMEMBLOCK (pMemHeap, pMemBlk);
+
+               return (mem_p);
+            } 
+         }
+         else {
+            OSMemElemDescr* pNextElem, *pFreeElem; 
+            unsigned sumSize = pElem_nunits (pElem), freeMem = 0;
+         
+            RTMEMDIAG1 ("memHeapRealloc: look for free element after "
+               "current block.\n");
+
+            /* look for free element after pElem */
+
+            pNextElem = GETNEXT (pElem);
+            if (ISFREE (pNextElem)) {
+               /* +1 'cos sizeof (OSMemElemDescr) == 1 unit */
+               sumSize += pElem_nunits (pNextElem) + 1; 
+               freeMem++;
+            }
+            
+            if (sumSize >= nunits) {
+
+               RTMEMDIAG1 ("memHeapRealloc: reuse free element.\n");
+
+               if (ISFREE (pNextElem)) {
+                  pFreeElem = GET_FREE_ELEM (pMemBlk);
+                  if (pFreeElem == pNextElem) {
+                     FORCE_SET_FREE_ELEM (pMemBlk, GET_NEXT_FREE (pNextElem));
+                  }
+                  else if (pFreeElem < pElem) {
+                     
+                     /* look for previous free elem to correct nextFreeOff */
+
+                     for (; pFreeElem != 0 && pFreeElem < pNextElem;) {
+                        OSMemElemDescr* pNextFreeElem = 
+                           GET_NEXT_FREE (pFreeElem);
+                        if (pNextFreeElem == pNextElem) {
+                           if (pElem_nextFreeOff (pNextElem) != 0)
+                              pElem_nextFreeOff (pFreeElem) = QOFFSETOF 
+                                 (GET_NEXT_FREE (pNextElem), pFreeElem);
+                           else
+                              pElem_nextFreeOff (pFreeElem) = 0;
+                           CHECKMEMELEM (pMemBlk, pFreeElem);
+                           break;
+                        }
+                        pFreeElem = pNextFreeElem;
+                     }
+                  }
+               }
+
+               /* reuse empty elements after the pElem */
+               
+               pMemBlk->freeMem += freeMem;
+     
+               if (sumSize - nunits > 1) {
+                  OSMemElemDescr* pNewElem;
+               
+                  /* if sumSize is too large, then create new empty element */
+
+                  pNewElem = (OSMemElemDescr*) 
+                     (pElem_data (pElem) + nbytes);
+                  pElem_nunits (pNewElem) = (ASN1USINT)(sumSize - nunits - 1);
+
+                  initNewFreeElement (pMemBlk, pNewElem, pElem);
+
+                  pMemBlk->freeMem--; /* sizeof (OSMemElemDescr) == 1 unit */
+                  pMemBlk->freeMem -= (nunits - pElem_nunits (pElem));
+                  pElem_nunits (pElem) = (ASN1USINT)nunits;
+               }
+               else {
+                  pMemBlk->freeMem -= (sumSize - pElem_nunits (pElem));
+                  pElem_nunits (pElem) = (ASN1USINT)sumSize;
+
+                  /* modify the prevOff of the next elem */
+
+                  pNextElem = GETNEXT (pElem);
+                  if (pNextElem != 0)
+                     pElem_prevOff (pNextElem) = QOFFSETOF (pNextElem, pElem);
+               }
+               
+               TRACEMEMELEM (pMemBlk, pElem, "Reallocated");
+               CHECKMEMELEM (pMemBlk, pElem);
+               CHECKMEMELEM (pMemBlk, (!ISLAST (pElem)) ? GETNEXT (pElem) : 0);
+               CHECKMEMBLOCK (pMemHeap, pMemBlk);
+               return (mem_p);
+            }
+         }
+      }
+
+      /* If not successful, allocate a new element and move the data into it */
+
+      RTMEMDIAG1 ("memHeapRealloc: allocate new memory...\n");
+
+      CHECKMEMHEAP (pMemHeap);
+
+      newMem_p = memHeapAlloc (ppvMemHeap, nbytes);
+      
+      if (newMem_p == 0)
+         return 0;
+
+      /* if the old memory block is marked as saved then mark the new block
+         as saved as well. */
+
+      if (ISSAVED (pElem)) 
+         memHeapMarkSaved (ppvMemHeap, newMem_p, TRUE);
+
+      CHECKMEMHEAP (pMemHeap);
+
+      memcpy (newMem_p, mem_p, (((ASN1UINT)pElem_nunits (pElem)) * 8u));
+
+      /* free old element */
+
+      RTMEMDIAG1 ("memHeapRealloc: free old pointer...\n");
+
+      memHeapFreePtr (ppvMemHeap, mem_p);
+
+      CHECKMEMHEAP (pMemHeap);
+
+      return (newMem_p);
+   }
+   else { /* shrinking */
+      RTMEMDIAG1 ("memHeapRealloc: shrinking ...\n");
+      
+      /* just free the pointer, if nbytes == 0 */
+
+      if (nbytes == 0) {
+         RTMEMDIAG1 ("memHeapRealloc: free pointer...\n");
+         memHeapFreePtr (ppvMemHeap, mem_p);
+         return (NULL);
+      }
+
+      /* do not shrink, if size diff is too small */
+
+      /* sizeof (OSMemElemDescr) == 1 unit */
+      if (pElem_nunits (pElem) - nunits > 1) { 
+         
+         /* if it is the last element in the block, then just change the size 
+            and free_x. */
+
+         if (ISLAST (pElem)) {
+            pMemBlk->free_x -= (pElem_nunits (pElem) - nunits);
+
+            FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u], 
+               (pElem_nunits (pElem) - nunits) * 8u);
+         }
+         else {
+            OSMemElemDescr* pNewElem;
+
+            /* create new free element on the freed place */
+
+            pNewElem = (OSMemElemDescr*) (pElem_data (pElem) + nbytes);
+
+            /* sizeof (OSMemElemDescr) == 1 unit */
+            pElem_nunits (pNewElem) = (ASN1USINT)(pElem_nunits (pElem) - nunits - 1); 
+            
+            initNewFreeElement (pMemBlk, pNewElem, pElem);
+            
+            pMemBlk->freeMem += (pElem_nunits (pElem) - nunits) - 1;
+         }
+         pElem_nunits (pElem) = (ASN1USINT)nunits;
+         
+         TRACEMEMELEM (pMemBlk, pElem, "Reallocated");
+         CHECKMEMELEM (pMemBlk, pElem);
+         CHECKMEMELEM (pMemBlk, (!ISLAST (pElem)) ? GETNEXT (pElem) : pElem);
+         CHECKMEMBLOCK (pMemHeap, pMemBlk);
+      }
+      return (mem_p);
+   }
+}
+
+/* Clears heap memory (frees all memory, reset all heap's variables) */
+void memHeapFreeAll (void** ppvMemHeap)
+{
+   OSMemHeap* pMemHeap;
+   OSMemLink* pMemLink;
+   OSMemLink* pMemLink2;
+
+   if (ppvMemHeap == 0 || *ppvMemHeap == 0) return;
+   pMemHeap = *(OSMemHeap**)ppvMemHeap;
+
+   pMemLink = pMemHeap->phead;
+   RTMEMDIAG2 ("memHeapFreeAll: pMemHeap = 0x%x\n", pMemHeap);
+
+   TRACEFREE (pMemHeap, "memHeapFreeAll\n\n");
+   CHECKMEMHEAP (pMemHeap);
+
+   /* Release any dynamic memory blocks that may have been allocated */
+
+   while (pMemLink) {
+      pMemLink2 = pMemLink;
+      pMemLink  = pMemLink2->pnext;
+
+      RTMEMDIAG3 ("memHeapFreeAll: pMemLink2 = 0x%x, pMemLink = 0x%x\n", 
+                  pMemLink2, pMemLink);
+      
+#ifdef _MEMDEBUG
+      if (pMemLink2->blockType & RTMEMSTD) {
+         OSMemBlk* pMemBlk = (OSMemBlk*) pMemLink2->pMemBlk;
+         FILLFREEMEM (pMemBlk->data, (pMemBlk->nunits * 8u));
+         FILLFREEMEM (pMemBlk, sizeof (*pMemBlk));
+      }
+#endif
+      if (!(pMemLink2->blockType & RTMEMSAVED)) {
+         OSMemBlk* pMemBlk = (OSMemBlk*) pMemLink2->pMemBlk;
+
+         /* unlink block first */
+
+         if(pMemLink2->pnext != 0) {
+            pMemLink2->pnext->pprev = pMemLink2->pprev;
+         }
+         if(pMemLink2->pprev != 0) {
+            pMemLink2->pprev->pnext = pMemLink2->pnext;
+         }
+         else { /* head */
+            pMemHeap->phead = pMemLink2->pnext;
+         }
+
+         /* correct heap's variables */
+
+         pMemHeap->usedUnits -= pMemBlk->nunits;
+
+         if (pMemBlk->free_x == 0)
+            pMemHeap->freeBlocks --;
+         else
+            pMemHeap->usedBlocks --;
+
+         /* free link and block */
+
+         if (((pMemLink2->blockType & RTMEMSTD) || 
+              (pMemLink2->blockType & RTMEMMALLOC)) &&
+              !(pMemLink2->blockType & RTMEMLINK)) 
+            g_free_func (pMemLink2->pMemBlk);
+         g_free_func (pMemLink2);
+      }
+   }
+}
+
+/* increments internal refCnt. use memHeapRelease to decrement and release */
+void memHeapAddRef (void** ppvMemHeap)
+{
+   OSMemHeap* pMemHeap;
+
+   if (ppvMemHeap == 0 || *ppvMemHeap == 0) return;
+   pMemHeap = *(OSMemHeap**)ppvMemHeap;
+   pMemHeap->refCnt++;
+}
+
+/* Frees all memory and heap structure as well (if was allocated) */
+void memHeapRelease (void** ppvMemHeap)
+{
+   OSMemHeap** ppMemHeap = (OSMemHeap**)ppvMemHeap;
+
+   if (ppMemHeap != 0 && *ppMemHeap != 0 && --(*ppMemHeap)->refCnt == 0) {
+      OSMemLink* pMemLink, *pMemLink2;
+
+      memHeapFreeAll (ppvMemHeap);
+
+      /* if there are RTMEMSAVED blocks - release memory for links only */
+
+      pMemLink = (*ppMemHeap)->phead;
+      while (pMemLink) {
+         pMemLink2 = pMemLink;
+         pMemLink  = pMemLink2->pnext;
+
+         free (pMemLink2);
+      }
+
+      if ((*ppMemHeap)->flags & RT_MH_FREEHEAPDESC)
+         free (*ppMemHeap);
+
+      *ppMemHeap = 0;
+   }
+}
+
+/* This function is used for marking memory block as "saved". It means
+ * that the memory block containing the specified memory pointer won't be
+ * freed after calls to memHeapFreeAll/memHeapReset. User is responsible 
+ * for freeing the marked memory block by call to memFreeBlock */
+
+void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, 
+                        ASN1BOOL saved) 
+{
+   OSMemHeap* pMemHeap;
+   OSMemLink* pMemLink;
+   ASN1UINT nsaved = 1;
+
+   RTMEMDIAG2 ("memHeapMarkSaved: for mem_p = 0x%x\n", mem_p);
+
+   if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0) 
+      return 0;
+
+   pMemHeap = *(OSMemHeap**)ppvMemHeap;
+   pMemLink = pMemHeap->phead;
+
+   /* look for chain of RAW blocks first */
+
+   for (; pMemLink != 0; pMemLink = pMemLink->pnextRaw) {
+      if ((pMemLink->blockType & RTMEMRAW) &&
+           pMemLink->pMemBlk == mem_p) 
+      {
+         break;
+      }
+   }
+   if (pMemLink == 0) {
+      OSMemElemDescr* pElem;
+      OSMemBlk* pMemBlk;
+
+      /* gain the MemLink from pointer */
+
+      pElem = (OSMemElemDescr*) (((char*)mem_p) - sizeof_OSMemElemDescr);
+
+      if (ISFREE (pElem)) { /* already freed! */
+         RTMEMDIAG2 ("memHeapMarkSaved: the element 0x%x is "
+                         "already free!\n", pElem);
+         return 0;   
+      }
+
+      if ((ISSAVED (pElem) && !saved) || (!ISSAVED (pElem) && saved)) {
+
+         pMemBlk = GET_MEMBLK (pElem);
+
+         CHECKMEMELEM (pMemBlk, pElem);
+         CHECKMEMBLOCK(pMemHeap, pMemBlk);
+
+         pMemLink = pMemBlk->plink;
+
+         if (saved) 
+            SET_SAVED (pMemBlk, pElem);
+         else
+            CLEAR_SAVED (pMemBlk, pElem);
+         nsaved = pMemBlk->nsaved;
+      }
+      else
+         return 0;
+   }
+   if (saved && nsaved > 0) 
+      pMemLink->blockType |= RTMEMSAVED;
+   else if (nsaved == 0)
+      pMemLink->blockType &= (~RTMEMSAVED);
+   return pMemLink->pMemBlk;
+}
+
+/* This function will set the free index in all blocks to zero thereby  */
+/* allowing the blocks to be reused (ED, 3/17/2002)..                   */
+
+void memHeapReset (void** ppvMemHeap)
+{
+   OSMemHeap* pMemHeap;
+   OSMemLink *pMemLink;
+
+   if (ppvMemHeap == 0 || *ppvMemHeap == 0) return;
+   pMemHeap = *(OSMemHeap**)ppvMemHeap;
+
+   pMemLink = pMemHeap->phead;
+   TRACEFREE (pMemHeap, "memHeapReset\n\n");
+   while (pMemLink) {
+      if (!(pMemLink->blockType & RTMEMSAVED)) {
+         if (pMemLink->blockType & RTMEMSTD) {
+            OSMemBlk* pMemBlk = (OSMemBlk*) pMemLink->pMemBlk;
+            if (pMemBlk->free_x != 0) {
+               pMemHeap->freeUnits += pMemBlk->nunits;
+               pMemHeap->freeBlocks ++;
+            }
+            pMemBlk->free_x = 0;
+            pMemBlk->freeElemOff = 0;
+            pMemBlk->lastElemOff = 0;
+            pMemBlk->freeMem = 0;
+            FILLFREEMEM (pMemBlk->data, pMemBlk->nunits * 8u);
+         }
+         else if (pMemLink->blockType & RTMEMRAW) {
+            /* if RAW block - free it */
+            memHeapFreePtr (ppvMemHeap, pMemLink->pMemBlk);
+         }
+      }
+      pMemLink = pMemLink->pnext;
+   }
+}
+
+/* add memory block to list */
+
+static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, 
+                                     void* pMemBlk, int blockType)
+{
+   OSMemLink* pMemLink;
+
+   /* if pMemBlk has RTMEMLINK flags it means that it is allocated 
+    * cooperatively with OSMemLink, and we don't need to do additional
+    * allocations for it. Just use pointer's arithemtic. */
+
+   if (blockType & RTMEMLINK) 
+      pMemLink = (OSMemLink*) (((ASN1OCTET*)pMemBlk) - sizeof (OSMemLink));
+   else {
+      pMemLink = (OSMemLink*) g_malloc_func (
+         sizeof(OSMemLink) + sizeof (int));
+      if (pMemLink == 0) return 0;
+      /* An extra integer is necessary to save a size of a RAW memory block
+         to perform rtMemRealloc through malloc/memcpy/free */
+      *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = (int)-1;
+   }
+   if (pMemLink == NULL) 
+      return NULL;
+   pMemLink->blockType = (ASN1OCTET)blockType;
+   pMemLink->pMemBlk = pMemBlk;
+   pMemLink->pprev = 0;
+   pMemLink->pnext = *ppMemLink;
+
+   if (*ppMemLink != 0) {
+      if ((*ppMemLink)->blockType & RTMEMRAW)
+         pMemLink->pnextRaw = *ppMemLink;
+      else {
+         pMemLink->pnextRaw = (*ppMemLink)->pnextRaw;
+         (*ppMemLink)->pnextRaw = 0;
+      }
+   }
+   else {
+      pMemLink->pnextRaw = 0;
+   }
+
+   *ppMemLink = pMemLink; 
+   if (pMemLink->pnext != 0)
+      pMemLink->pnext->pprev = pMemLink;
+   ((OSMemBlk*)pMemBlk)->plink = pMemLink; /*!AB */
+
+   RTMEMDIAG2 ("memHeapAddBlock: pMemLink = 0x%x\n", pMemLink);
+   RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pnext = 0x%x\n", 
+                    pMemLink->pnext);
+   RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pprev = 0x%x\n", 
+                    pMemLink->pprev);
+
+   return pMemLink;
+}
+
+int memHeapCheckPtr (void** ppvMemHeap, void* mem_p)
+{
+   OSMemHeap* pMemHeap;
+   OSMemLink* pMemLink;
+
+   RTMEMDIAG2 ("memHeapCheckPtr: for mem_p = 0x%x\n", mem_p);
+
+   if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0) 
+      return 0;
+   pMemHeap = *(OSMemHeap**)ppvMemHeap;
+
+   pMemLink = pMemHeap->phead;
+
+   for (; pMemLink != 0; pMemLink = pMemLink->pnext) {
+      if (pMemLink->blockType & RTMEMRAW) {
+         
+         /* if RAW block, the pointer should be stored in pMemBlk */
+
+         if (pMemLink->pMemBlk == mem_p) 
+            return 1;
+      }
+      else {
+         OSMemBlk* pMemBlk = (OSMemBlk*)pMemLink->pMemBlk;
+         
+         /* Check, is the pointer inside this memory page */
+
+         if (mem_p > pMemLink->pMemBlk && 
+             mem_p < (void*)(((ASN1OCTET*)pMemLink->pMemBlk) + pMemBlk->nunits * 8u))
+         {
+            /* Check, is the pointer a correct element of the mem page */
+
+            OSMemElemDescr* pElem = (OSMemElemDescr*) pMemBlk->data;
+            for (; pElem != 0; pElem = GETNEXT (pElem)) {
+              
+               void* curMem_p = (void*) pElem_data (pElem);
+               if (curMem_p == mem_p && !ISFREE (pElem))
+                  return 1;
+            }
+         }
+      }
+   }
+   return 0;
+}
+
+void memHeapSetProperty (void** ppvMemHeap, ASN1UINT propId, void* pProp)
+{
+   OSMemHeap* pMemHeap;
+
+   if (ppvMemHeap == 0) 
+      return;
+
+   if (*ppvMemHeap == 0)
+      memHeapCreate (ppvMemHeap);
+
+   pMemHeap = *(OSMemHeap**)ppvMemHeap;
+   switch (propId) {
+      case OSRTMH_PROPID_DEFBLKSIZE:
+         pMemHeap->defBlkSize = *(ASN1UINT*)pProp;
+         break;
+      case OSRTMH_PROPID_SETFLAGS:
+         pMemHeap->flags |= ((*(ASN1UINT*)pProp) & (~RT_MH_INTERNALMASK));
+         break;
+      case OSRTMH_PROPID_CLEARFLAGS:
+         pMemHeap->flags &= ((~(*(ASN1UINT*)pProp)) | RT_MH_INTERNALMASK);
+         break;
+   }
+} 
+
+int memHeapCreate (void** ppvMemHeap) 
+{
+   OSMemHeap* pMemHeap;
+   if (ppvMemHeap == 0) return ASN_E_INVPARAM;
+
+   pMemHeap = (OSMemHeap*) g_malloc_func (sizeof (OSMemHeap));
+   if (pMemHeap == NULL) return ASN_E_NOMEM;
+   memset (pMemHeap, 0, sizeof (OSMemHeap));
+   pMemHeap->defBlkSize = g_defBlkSize;
+   pMemHeap->refCnt = 1;
+   pMemHeap->flags = RT_MH_FREEHEAPDESC;
+   *ppvMemHeap = (void*)pMemHeap;
+   return ASN_OK;
+}
+
diff --git a/addons/ooh323c/src/memheap.h b/addons/ooh323c/src/memheap.h
new file mode 100644
index 000000000..b99f9dbc9
--- /dev/null
+++ b/addons/ooh323c/src/memheap.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#ifndef __RTMEMHEAP_HH__
+#define __RTMEMHEAP_HH__
+
+#include "ooasn1.h"
+
+/* internal heap flags */
+#define RT_MH_INTERNALMASK 0xF0000000u
+#define RT_MH_FREEHEAPDESC 0x10000000u
+
+typedef struct OSMemLink {
+   struct OSMemLink* pnext;
+   struct OSMemLink* pprev;
+   struct OSMemLink* pnextRaw;  /* next RAW block                           */
+   void*           pMemBlk;
+   ASN1OCTET       blockType;   /* 1 = standard, 2 = raw (see RTMEM* flags) */
+} OSMemLink;
+
+/* MemLink blockTypes */
+#define RTMEMSTD        0x0001
+#define RTMEMRAW        0x0002
+#define RTMEMMALLOC     0x0004
+#define RTMEMSAVED      0x0008
+#define RTMEMLINK       0x0010  /* contains MemLink */
+
+/* ASN.1 memory allocation structures */
+
+typedef struct OSMemHeap {
+   OSMemLink*      phead;
+   ASN1UINT        usedUnits;
+   ASN1UINT        usedBlocks;
+   ASN1UINT        freeUnits;
+   ASN1UINT        freeBlocks;
+   ASN1UINT        keepFreeUnits;
+   ASN1UINT        defBlkSize;
+   ASN1UINT        refCnt;
+   ASN1UINT        flags;
+} OSMemHeap;
+
+/* see rtMemDefs.c file */
+extern ASN1UINT      g_defBlkSize;
+extern OSMallocFunc  g_malloc_func;
+extern OSReallocFunc g_realloc_func;
+extern OSFreeFunc    g_free_func;
+
+#endif /* __RTMEMHEAP_HH__ */
diff --git a/addons/ooh323c/src/ooCalls.c b/addons/ooh323c/src/ooCalls.c
new file mode 100644
index 000000000..33f584c5a
--- /dev/null
+++ b/addons/ooh323c/src/ooCalls.c
@@ -0,0 +1,820 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ootrace.h"
+#include "ootypes.h"
+#include "ooCalls.h"
+#include "ooUtils.h"
+#include "ooports.h"
+#include "oochannels.h"
+#include "ooh245.h"
+#include "ooCapability.h"
+#include "ooGkClient.h"
+#include "ooh323ep.h"
+#include "ooCalls.h"
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+OOH323CallData* ooCreateCall(char* type, char*callToken)
+{
+   OOH323CallData *call=NULL;
+   OOCTXT *pctxt=NULL;
+
+   pctxt = newContext();
+   if(!pctxt)
+   {
+      OOTRACEERR1("ERROR:Failed to create OOCTXT for new call\n");
+      return NULL;
+   }
+   call = (OOH323CallData*)memAlloc(pctxt, sizeof(OOH323CallData));
+   if(!call)
+   {
+      OOTRACEERR1("ERROR:Memory - ooCreateCall - call\n");
+      return NULL;
+   } 
+   /*   memset(call, 0, sizeof(OOH323CallData));*/
+   call->pctxt = pctxt;
+   call->callMode = gH323ep.callMode;
+   sprintf(call->callToken, "%s", callToken);
+   sprintf(call->callType, "%s", type);
+   call->callReference = 0;
+   if(gH323ep.callerid) {
+     strncpy(call->ourCallerId, gH323ep.callerid, sizeof(call->ourCallerId)-1);
+     call->ourCallerId[sizeof(call->ourCallerId)-1] = '\0';
+   }
+   else {
+      call->ourCallerId[0] = '\0';
+   }
+   
+   memset(&call->callIdentifier, 0, sizeof(H225CallIdentifier));
+   memset(&call->confIdentifier, 0, sizeof(H225ConferenceIdentifier));
+
+   call->flags = 0;
+   if (OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING))
+      OO_SETFLAG (call->flags, OO_M_TUNNELING);
+
+   if(gH323ep.gkClient)
+   {
+      if(OO_TESTFLAG(gH323ep.flags, OO_M_GKROUTED))
+      {
+         OO_SETFLAG(call->flags, OO_M_GKROUTED);
+      }
+   }
+
+   if (OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART))
+      OO_SETFLAG (call->flags, OO_M_FASTSTART);
+
+   if (OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN))
+      OO_SETFLAG (call->flags, OO_M_MEDIAWAITFORCONN);
+   
+   call->callState = OO_CALL_CREATED;
+   call->callEndReason = OO_REASON_UNKNOWN;
+   call->pCallFwdData = NULL;
+
+   if(!strcmp(call->callType, "incoming"))
+   {
+      call->callingPartyNumber = NULL;
+   }
+   else{      
+      if(ooUtilsIsStrEmpty(gH323ep.callingPartyNumber))
+      {
+         call->callingPartyNumber = NULL;
+      }
+      else{
+         call->callingPartyNumber = (char*) memAlloc(call->pctxt, 
+                                         strlen(gH323ep.callingPartyNumber)+1);
+         if(call->callingPartyNumber)
+         {
+            strcpy(call->callingPartyNumber, gH323ep.callingPartyNumber);
+         }
+         else{
+            OOTRACEERR3("Error:Memory - ooCreateCall - callingPartyNumber"
+                        ".(%s, %s)\n", call->callType, call->callToken);
+            freeContext(pctxt);
+            return NULL;
+         }
+      }
+   }
+
+   call->calledPartyNumber = NULL;
+   call->h245ConnectionAttempts = 0;
+   call->h245SessionState = OO_H245SESSION_IDLE;
+   call->dtmfmode = gH323ep.dtmfmode;
+   call->mediaInfo = NULL;
+   strcpy(call->localIP, gH323ep.signallingIP);
+   call->pH225Channel = NULL;
+   call->pH245Channel = NULL;
+   call->h245listener = NULL;
+   call->h245listenport = NULL;
+   call->remoteIP[0] = '\0';
+   call->remotePort = 0;
+   call->remoteH245Port = 0;
+   call->remoteDisplayName = NULL;
+   call->remoteAliases = NULL;
+   call->ourAliases = NULL;
+   call->masterSlaveState = OO_MasterSlave_Idle;
+   call->statusDeterminationNumber = 0;
+   call->localTermCapState = OO_LocalTermCapExchange_Idle;
+   call->remoteTermCapState = OO_RemoteTermCapExchange_Idle; 
+   call->ourCaps = NULL;
+   call->remoteCaps = NULL;
+   call->jointCaps = NULL;
+   dListInit(&call->remoteFastStartOLCs);
+   call->remoteTermCapSeqNo =0;
+   call->localTermCapSeqNo = 0;
+   memcpy(&call->capPrefs, &gH323ep.capPrefs, sizeof(OOCapPrefs));    
+   call->logicalChans = NULL;
+   call->noOfLogicalChannels = 0;
+   call->logicalChanNoBase = 1001;
+   call->logicalChanNoMax = 1100;
+   call->logicalChanNoCur = 1001;
+   call->nextSessionID = 4; /* 1,2,3 are reserved for audio, video and data */
+   dListInit(&call->timerList);
+   call->msdRetries = 0;
+   call->pFastStartRes = NULL;
+   call->usrData = NULL;
+   OOTRACEINFO3("Created a new call (%s, %s)\n", call->callType, 
+                 call->callToken);
+   /* Add new call to calllist */
+   ooAddCallToList (call);
+   if(gH323ep.h323Callbacks.onNewCallCreated)
+     gH323ep.h323Callbacks.onNewCallCreated(call);
+   return call;
+}
+
+int ooAddCallToList(OOH323CallData *call)
+{
+   if(!gH323ep.callList)
+   {
+      gH323ep.callList = call;
+      call->next = NULL;
+      call->prev = NULL;
+   }
+   else{
+      call->next = gH323ep.callList;
+      call->prev = NULL;
+      gH323ep.callList->prev = call;
+      gH323ep.callList = call;
+   }
+   return OO_OK;
+}
+
+
+int ooEndCall(OOH323CallData *call)
+{
+   OOTRACEDBGA4("In ooEndCall call state is - %s (%s, %s)\n", 
+                 ooGetCallStateText(call->callState), call->callType, 
+                 call->callToken);
+
+   if(call->callState == OO_CALL_CLEARED)
+   {
+      ooCleanCall(call); 
+      return OO_OK;
+   }
+
+   if(call->logicalChans)
+   {
+      OOTRACEINFO3("Clearing all logical channels. (%s, %s)\n", call->callType,
+                    call->callToken);
+      ooClearAllLogicalChannels(call);
+   }
+
+   if(!OO_TESTFLAG(call->flags, OO_M_ENDSESSION_BUILT))
+   {
+      if(call->h245SessionState == OO_H245SESSION_ACTIVE ||
+         call->h245SessionState == OO_H245SESSION_ENDRECVD)
+      {
+         ooSendEndSessionCommand(call);
+         OO_SETFLAG(call->flags, OO_M_ENDSESSION_BUILT);
+      }
+   }
+
+
+   if(!call->pH225Channel || call->pH225Channel->sock ==0)
+   {
+      call->callState = OO_CALL_CLEARED;
+   }
+   else{
+      if(!OO_TESTFLAG(call->flags, OO_M_RELEASE_BUILT))   
+      {
+         if(call->callState == OO_CALL_CLEAR || 
+            call->callState == OO_CALL_CLEAR_RELEASERECVD)
+         {
+            ooSendReleaseComplete(call);
+            OO_SETFLAG(call->flags, OO_M_RELEASE_BUILT);
+         }
+      }
+   }
+      
+   return OO_OK;
+}
+
+
+
+int ooRemoveCallFromList (OOH323CallData *call)
+{
+   if(!call)
+      return OO_OK;
+
+   if(call == gH323ep.callList)
+   {
+      if(!call->next)
+         gH323ep.callList = NULL;
+      else{
+         call->next->prev = NULL;
+         gH323ep.callList = call->next;
+      }
+   }
+   else{
+      call->prev->next = call->next;
+      if(call->next)
+         call->next->prev = call->prev;
+   }
+   return OO_OK;
+}
+
+int ooCleanCall(OOH323CallData *call)
+{
+   OOCTXT *pctxt;
+
+   OOTRACEWARN4 ("Cleaning Call (%s, %s)- reason:%s\n", 
+                 call->callType, call->callToken, 
+                 ooGetReasonCodeText (call->callEndReason));
+
+   /* First clean all the logical channels, if not already cleaned. */
+   if(call->logicalChans)
+      ooClearAllLogicalChannels(call);
+   
+   /* Close H.245 connection, if not already closed */
+   if(call->h245SessionState != OO_H245SESSION_CLOSED)
+      ooCloseH245Connection(call);
+   else{
+      if(call->pH245Channel && call->pH245Channel->outQueue.count > 0)
+      {
+         dListFreeAll(call->pctxt, &(call->pH245Channel->outQueue));
+         memFreePtr(call->pctxt, call->pH245Channel);
+      }
+   }
+
+   /* Close H.245 listener, if not already closed */
+   if(call->h245listener)
+   {
+      ooCloseH245Listener(call);
+   }
+   
+   /* Close H225 connection, if not already closed. */
+   if (0 != call->pH225Channel && 0 != call->pH225Channel->sock)
+   {
+      ooCloseH225Connection(call);
+   }
+
+   /* Clean timers */
+   if(call->timerList.count > 0)
+   {
+      dListFreeAll(call->pctxt, &(call->timerList));
+   }
+
+   if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK))
+   {
+      ooGkClientCleanCall(gH323ep.gkClient, call);
+   }
+
+   ooRemoveCallFromList (call);
+   OOTRACEINFO3("Removed call (%s, %s) from list\n", call->callType, 
+                 call->callToken);
+
+   if(call->pCallFwdData && call->pCallFwdData->fwdedByRemote)
+   {
+
+      if(gH323ep.h323Callbacks.onCallForwarded)
+         gH323ep.h323Callbacks.onCallForwarded(call);
+
+      if(ooH323HandleCallFwdRequest(call)!= OO_OK)
+      {
+         OOTRACEERR3("Error:Failed to forward call (%s, %s)\n", call->callType,
+                     call->callToken);
+      }
+   }
+   else {
+      if(gH323ep.h323Callbacks.onCallCleared)
+         gH323ep.h323Callbacks.onCallCleared(call);
+   }
+
+   pctxt = call->pctxt;
+   freeContext(pctxt);
+   ASN1CRTFREE0(pctxt);
+   return OO_OK;
+}
+
+
+int ooCallSetCallerId(OOH323CallData* call, const char* callerid)
+{
+   if(!call || !callerid) return OO_FAILED;
+   strncpy(call->ourCallerId, callerid, sizeof(call->ourCallerId)-1);
+   call->ourCallerId[sizeof(call->ourCallerId)-1]='\0';
+   return OO_OK;
+}
+
+int ooCallSetCallingPartyNumber(OOH323CallData *call, const char *number)
+{
+   if(call->callingPartyNumber) 
+      memFreePtr(call->pctxt, call->callingPartyNumber);
+
+   call->callingPartyNumber = (char*) memAlloc(call->pctxt, strlen(number)+1);
+   if(call->callingPartyNumber)
+   {
+     strcpy(call->callingPartyNumber, number);
+   }
+   else{
+      OOTRACEERR3("Error:Memory - ooCallSetCallingPartyNumber - "
+                  "callingPartyNumber.(%s, %s)\n", call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   /* Set dialed digits alias */
+   /*   if(!strcmp(call->callType, "outgoing"))
+   {
+      ooCallAddAliasDialedDigits(call, number);
+   }*/
+   return OO_OK;
+}
+
+int ooCallGetCallingPartyNumber(OOH323CallData *call, char *buffer, int len)
+{
+   if(call->callingPartyNumber)
+   {
+      if(len>(int)strlen(call->callingPartyNumber))
+      {
+         strcpy(buffer, call->callingPartyNumber);
+         return OO_OK;
+      }
+   }
+   
+   return OO_FAILED;
+}
+
+
+int ooCallSetCalledPartyNumber(OOH323CallData *call, const char *number)
+{
+   if(call->calledPartyNumber) 
+      memFreePtr(call->pctxt, call->calledPartyNumber);
+
+   call->calledPartyNumber = (char*) memAlloc(call->pctxt, strlen(number)+1);
+   if(call->calledPartyNumber)
+   {
+     strcpy(call->calledPartyNumber, number);
+   }
+   else{
+      OOTRACEERR3("Error:Memory - ooCallSetCalledPartyNumber - "
+                  "calledPartyNumber.(%s, %s)\n", call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   return OO_OK;
+}
+
+int ooCallGetCalledPartyNumber(OOH323CallData *call, char *buffer, int len)
+{
+   if(call->calledPartyNumber)
+   {
+      if(len>(int)strlen(call->calledPartyNumber))
+      {
+         strcpy(buffer, call->calledPartyNumber);
+         return OO_OK;
+      }
+   }
+   
+   return OO_FAILED;
+}
+
+int ooCallClearAliases(OOH323CallData *call)
+{
+   if(call->ourAliases)
+      memFreePtr(call->pctxt, call->ourAliases);
+   call->ourAliases = NULL;
+   return OO_OK;
+}
+
+
+int ooCallAddAlias
+   (OOH323CallData *call, int aliasType, const char *value, OOBOOL local)
+{
+   ooAliases * psNewAlias=NULL;
+   psNewAlias = (ooAliases*)memAlloc(call->pctxt, sizeof(ooAliases));
+   if(!psNewAlias)
+   {
+      OOTRACEERR3("Error:Memory - ooCallAddAlias - psNewAlias"
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   psNewAlias->type = aliasType;
+   psNewAlias->value = (char*) memAlloc(call->pctxt, strlen(value)+1);
+   if(!psNewAlias->value)
+   {
+      OOTRACEERR3("Error:Memory - ooCallAddAlias - psNewAlias->value"
+                  " (%s, %s)\n", call->callType, call->callToken);
+      memFreePtr(call->pctxt, psNewAlias);
+      return OO_FAILED;
+   }
+   strcpy(psNewAlias->value, value);
+
+   if(local)
+   {
+      psNewAlias->next = call->ourAliases;
+      call->ourAliases = psNewAlias;
+   }
+   else {
+     psNewAlias->next = call->remoteAliases;
+     call->remoteAliases = psNewAlias;
+   }
+
+   OOTRACEDBGC5("Added %s alias %s to call. (%s, %s)\n", 
+              local?"local":"remote", value, call->callType, call->callToken);
+   return OO_OK;
+}
+
+int ooCallAddAliasH323ID(OOH323CallData *call, const char* h323id)
+{
+   return ooCallAddAlias(call, T_H225AliasAddress_h323_ID, h323id, TRUE);
+}
+
+
+int ooCallAddAliasDialedDigits(OOH323CallData *call, const char* dialedDigits)
+{
+   return ooCallAddAlias
+               (call, T_H225AliasAddress_dialedDigits, dialedDigits, TRUE);
+}
+
+
+int ooCallAddAliasEmailID(OOH323CallData *call, const char* email)
+{
+   return ooCallAddAlias(call, T_H225AliasAddress_email_ID, email, TRUE);
+}
+
+
+int ooCallAddAliasURLID(OOH323CallData *call, const char* url)
+{
+   return ooCallAddAlias(call, T_H225AliasAddress_url_ID, url, TRUE);
+} 
+ 
+
+int ooCallAddRemoteAliasH323ID(OOH323CallData *call, const char* h323id)
+{
+   return ooCallAddAlias(call, T_H225AliasAddress_h323_ID, h323id, FALSE);
+}
+
+int ooCallAddRemoteAliasDialedDigits
+   (OOH323CallData *call, const char* dialedDigits)
+{
+   return ooCallAddAlias
+              (call, T_H225AliasAddress_dialedDigits, dialedDigits, FALSE);
+}
+
+
+
+/* Used to override global end point capabilities and add call specific 
+   capabilities */
+
+int ooCallAddG7231Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, OOBOOL silenceSuppression, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, 
+                                silenceSuppression, dir, startReceiveChannel, 
+                                startTransmitChannel, stopReceiveChannel, 
+                                stopTransmitChannel, FALSE);
+}
+
+
+
+int ooCallAddG729Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, FALSE,
+                          dir, startReceiveChannel, startTransmitChannel, 
+                          stopReceiveChannel, stopTransmitChannel, FALSE);
+}
+
+/*
+int ooCallAddG726Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, FALSE,
+                          dir, startReceiveChannel, startTransmitChannel, 
+                          stopReceiveChannel, stopTransmitChannel, FALSE);
+}
+*/
+
+int ooCallAddG728Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, FALSE,
+                          dir, startReceiveChannel, startTransmitChannel, 
+                          stopReceiveChannel, stopTransmitChannel, FALSE);
+}
+
+int ooCallAddG711Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, FALSE,
+                            dir, startReceiveChannel, startTransmitChannel, 
+                            stopReceiveChannel, stopTransmitChannel, FALSE);
+}
+
+int ooCallAddGSMCapability
+   (OOH323CallData* call, int cap, ASN1USINT framesPerPkt, 
+    OOBOOL comfortNoise, OOBOOL scrambled, int dir,
+    cb_StartReceiveChannel startReceiveChannel,
+    cb_StartTransmitChannel startTransmitChannel,
+    cb_StopReceiveChannel stopReceiveChannel,
+    cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddGSMCapability(call, cap, framesPerPkt, comfortNoise, 
+                                     scrambled, dir, startReceiveChannel, 
+                                     startTransmitChannel, stopReceiveChannel,
+                                     stopTransmitChannel, FALSE);
+}
+
+
+int ooCallAddH263VideoCapability
+   (OOH323CallData *call, int cap, unsigned sqcifMPI, unsigned qcifMPI, 
+    unsigned cifMPI, unsigned cif4MPI, unsigned cif16MPI, unsigned maxBitRate, 
+    int dir, cb_StartReceiveChannel startReceiveChannel,
+    cb_StartTransmitChannel startTransmitChannel,
+    cb_StopReceiveChannel stopReceiveChannel,
+    cb_StopTransmitChannel stopTransmitChannel)
+{
+
+   return ooCapabilityAddH263VideoCapability(call, sqcifMPI, qcifMPI, cifMPI,
+                                     cif4MPI, cif16MPI, maxBitRate,dir,
+                                     startReceiveChannel, startTransmitChannel,
+                                     stopReceiveChannel, stopTransmitChannel, 
+                                     FALSE);
+
+}
+
+int ooCallEnableDTMFRFC2833(OOH323CallData *call, int dynamicRTPPayloadType)
+{
+   return ooCapabilityEnableDTMFRFC2833(call, dynamicRTPPayloadType);
+}
+
+int ooCallDisableDTMFRFC2833(OOH323CallData *call)
+{
+  return ooCapabilityDisableDTMFRFC2833(call);
+}
+
+
+int ooCallEnableDTMFH245Alphanumeric(OOH323CallData *call)
+{
+   return ooCapabilityEnableDTMFH245Alphanumeric(call);
+}
+
+int ooCallDisableDTMFH245Alphanumeric(OOH323CallData *call)
+{
+   return ooCapabilityDisableDTMFH245Alphanumeric(call);
+}
+
+int ooCallEnableDTMFH245Signal(OOH323CallData *call)
+{
+   return ooCapabilityEnableDTMFH245Signal(call);
+}
+
+int ooCallDisableDTMFH245Signal(OOH323CallData *call)
+{
+   return ooCapabilityDisableDTMFH245Signal(call);
+}
+
+int ooCallEnableDTMFQ931Keypad(OOH323CallData *call)
+{
+   return ooCapabilityEnableDTMFQ931Keypad(call);
+}
+
+int ooCallDisableDTMFQ931Keypad(OOH323CallData *call)
+{
+   return ooCapabilityDisableDTMFQ931Keypad(call);
+}
+
+
+OOH323CallData* ooFindCallByToken(char *callToken)
+{
+   OOH323CallData *call;
+   if(!callToken)
+   {
+      OOTRACEERR1("ERROR:Invalid call token passed - ooFindCallByToken\n");
+      return NULL;
+   }
+   if(!gH323ep.callList)
+   {
+      OOTRACEERR1("ERROR: Empty calllist - ooFindCallByToken failed\n");
+      return NULL;
+   }
+   call = gH323ep.callList;
+   while(call)
+   {
+      if(!strcmp(call->callToken, callToken))
+         break;
+      else
+         call = call->next;
+   }
+   
+   if(!call)
+   {
+      OOTRACEERR2("ERROR:Call with token %s not found\n", callToken);
+      return NULL;
+   }
+   return call;
+}
+
+
+
+/* Checks whether session with suplied ID and direction is already active*/
+ASN1BOOL ooIsSessionEstablished(OOH323CallData *call, int sessionID, char* dir)
+{
+   OOLogicalChannel * temp = NULL;
+   temp = call->logicalChans;
+   while(temp)
+   {
+      if(temp->sessionID == sessionID              &&
+         temp->state == OO_LOGICALCHAN_ESTABLISHED && 
+         !strcmp(temp->dir, dir)                     )
+         return TRUE;
+      temp = temp->next;
+   }
+   return FALSE;
+}
+
+int ooAddMediaInfo(OOH323CallData *call, OOMediaInfo mediaInfo)
+{
+   OOMediaInfo *newMediaInfo=NULL;
+
+   if(!call)
+   {
+      OOTRACEERR3("Error:Invalid 'call' param for ooAddMediaInfo.(%s, %s)\n",
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   newMediaInfo = (OOMediaInfo*) memAlloc(call->pctxt, sizeof(OOMediaInfo));
+   if(!newMediaInfo)
+   {
+      OOTRACEERR3("Error:Memory - ooAddMediaInfo - newMediaInfo. "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   memcpy (newMediaInfo, &mediaInfo, sizeof(OOMediaInfo));
+
+   OOTRACEDBGC4("Configured mediainfo for cap %s (%s, %s)\n", 
+                ooGetCapTypeText(mediaInfo.cap),
+                call->callType, call->callToken);
+   if(!call->mediaInfo) {
+      newMediaInfo->next = NULL;
+      call->mediaInfo = newMediaInfo;
+   }
+   else {
+      newMediaInfo->next = call->mediaInfo;
+      call->mediaInfo = newMediaInfo;
+   }
+   return OO_OK;
+}
+
+unsigned ooCallGenerateSessionID
+   (OOH323CallData *call, OOCapType type, char *dir)
+{
+   unsigned sessionID=0;
+
+   if(type == OO_CAP_TYPE_AUDIO)
+   {
+      if(!ooGetLogicalChannel(call, 1, dir))
+      {
+         sessionID = 1;
+      }
+      else{
+         if(call->masterSlaveState == OO_MasterSlave_Master)
+            sessionID = call->nextSessionID++;
+         else{
+            OOTRACEDBGC4("Session id for %s channel of type audio has to be "
+                        "provided by remote.(%s, %s)\n", dir, call->callType, 
+                         call->callToken);
+            sessionID = 0; /* Will be assigned by remote */
+         }
+      }
+   }
+
+   if(type == OO_CAP_TYPE_VIDEO)
+   {
+      if(!ooGetLogicalChannel(call, 2, dir))
+      {
+         sessionID = 2;
+      }
+      else{
+         if(call->masterSlaveState == OO_MasterSlave_Master)
+            sessionID = call->nextSessionID++;
+         else{
+            sessionID = 0; /* Will be assigned by remote */
+            OOTRACEDBGC4("Session id for %s channel of type video has to be "
+                        "provided by remote.(%s, %s)\n", dir, call->callType, 
+                         call->callToken);
+         }
+      }
+   }
+   return sessionID;
+
+}
+
+
+int ooCallH245ConnectionRetryTimerExpired(void *data)
+{
+   ooTimerCallback *cbData = (ooTimerCallback*) data;
+   OOH323CallData *call = cbData->call;
+
+   OOTRACEINFO3("H245 connection retry timer expired. (%s, %s)\n", 
+                                            call->callType, call->callToken); 
+   memFreePtr(call->pctxt, cbData);
+
+   call->h245ConnectionAttempts++;
+
+   ooCreateH245Connection(call);
+
+   return OO_OK;
+}
+
+const char* ooGetReasonCodeText (OOUINT32 code)
+{
+   static const char* reasonCodeText[] = {
+      "OO_REASON_UNKNOWN", 
+      "OO_REASON_INVALIDMESSAGE",
+      "OO_REASON_TRANSPORTFAILURE", 
+      "OO_REASON_NOROUTE",
+      "OO_REASON_NOUSER",
+      "OO_REASON_NOBW",
+      "OO_REASON_GK_NOCALLEDUSER",
+      "OO_REASON_GK_NOCALLERUSER",
+      "OO_REASON_GK_NORESOURCES",
+      "OO_REASON_GK_UNREACHABLE",
+      "OO_REASON_GK_CLEARED",
+      "OO_REASON_NOCOMMON_CAPABILITIES",
+      "OO_REASON_REMOTE_FWDED",   
+      "OO_REASON_LOCAL_FWDED",
+      "OO_REASON_REMOTE_CLEARED", 
+      "OO_REASON_LOCAL_CLEARED", 
+      "OO_REASON_REMOTE_BUSY",
+      "OO_REASON_LOCAL_BUSY",
+      "OO_REASON_REMOTE_NOANSWER",
+      "OO_REASON_LOCAL_NOTANSWERED",
+      "OO_REASON_REMOTE_REJECTED",
+      "OO_REASON_LOCAL_REJECTED",
+      "OO_REASON_REMOTE_CONGESTED",
+      "OO_REASON_LOCAL_CONGESTED"
+   };
+   return ooUtilsGetText (code, reasonCodeText, OONUMBEROF(reasonCodeText));
+}
+
+const char* ooGetCallStateText (OOCallState callState)
+{
+   static const char* callStateText[] = {
+      "OO_CALL_CREATED",
+      "OO_CALL_WAITING_ADMISSION",
+      "OO_CALL_CONNECTING",
+      "OO_CALL_CONNECTED",
+      "OO_CALL_PAUSED",
+      "OO_CALL_CLEAR",
+      "OO_CALL_CLEAR_RELEASERECVD",
+      "OO_CALL_CLEAR_RELEASESENT",
+      "OO_CALL_CLEARED"
+   };
+   return ooUtilsGetText (callState, callStateText, OONUMBEROF(callStateText));
+}
+
diff --git a/addons/ooh323c/src/ooCalls.h b/addons/ooh323c/src/ooCalls.h
new file mode 100644
index 000000000..64d62d6e1
--- /dev/null
+++ b/addons/ooh323c/src/ooCalls.h
@@ -0,0 +1,822 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file ooCalls.h 
+ * This file contains call management functions. 
+ */
+#ifndef _OOCALLS_H_
+#define _OOCALLS_H_
+
+#include "ooLogChan.h"
+#include "ooCapability.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** 
+ * @defgroup callmgmt  Call Management
+ * @{
+ */
+/* Flag mask values */
+/* DISABLEGK is used to selectively disable gatekeeper use. For incoming calls
+   DISABLEGK can be set in onReceivedSetup callback by application.
+   Very useful in pbx applications where gk is used only when call is
+   to or from outside pbx domian. For outgoing calls, ooMakeCallNoGk
+   disables use of gk for specific call.
+*/
+
+
+#define OO_M_ENDSESSION_BUILT   ASN1UINTCNT(0x00800000)
+#define OO_M_RELEASE_BUILT      ASN1UINTCNT(0x00400000)
+#define OO_M_FASTSTARTANSWERED  ASN1UINTCNT(0x04000000)
+
+#define OO_M_ENDPOINTCREATED    ASN1UINTCNT(0x00010000)
+#define OO_M_GKROUTED           ASN1UINTCNT(0x00200000)
+#define OO_M_AUTOANSWER         ASN1UINTCNT(0x00100000)
+#define OO_M_TUNNELING	        ASN1UINTCNT(0x08000000)
+#define OO_M_MEDIAWAITFORCONN   ASN1UINTCNT(0x20000000)
+#define OO_M_FASTSTART	        ASN1UINTCNT(0x02000000)
+#define OO_M_DISABLEGK          ASN1UINTCNT(0x01000000)
+#define OO_M_MANUALRINGBACK     ASN1UINTCNT(0x10000000)
+
+
+/** 
+ * Call states.
+ */
+typedef enum {
+   OO_CALL_CREATED,               /*!< Call created. */
+   OO_CALL_WAITING_ADMISSION,     /*!< Call waiting for admission by GK */
+   OO_CALL_CONNECTING,            /*!< Call in process of connecting */
+   OO_CALL_CONNECTED,             /*!< Call currently connected. */
+   OO_CALL_PAUSED,                /*!< Call Paused for hold/transfer. */
+   OO_CALL_CLEAR,                 /*!< Call marked for clearing */
+   OO_CALL_CLEAR_RELEASERECVD,    /*!< Release command received. */
+   OO_CALL_CLEAR_RELEASESENT,     /*!< Release sent */
+   OO_CALL_CLEARED                /*!< Call cleared */
+} OOCallState;
+
+/** 
+ * H.245 session states.
+ */
+typedef enum {
+   OO_H245SESSION_IDLE,
+   OO_H245SESSION_PAUSED,
+   OO_H245SESSION_ACTIVE,
+   OO_H245SESSION_ENDSENT, 
+   OO_H245SESSION_ENDRECVD,
+   OO_H245SESSION_CLOSED
+} OOH245SessionState;
+
+/**
+ * Structure to store local and remote media endpoint info for a 
+ * given media type.
+ */
+typedef struct OOMediaInfo{
+   char   dir[15]; /* transmit/receive*/
+   int   cap;
+   int   lMediaPort;
+   int   lMediaCntrlPort;
+   char  lMediaIP[20];
+   struct OOMediaInfo *next;
+} OOMediaInfo;
+
+#define ooMediaInfo OOMediaInfo
+
+struct OOAliases;
+
+/**
+ * Structure to hold information on a forwarded call.
+ */
+typedef struct OOCallFwdData {
+   char ip[20];
+   int port;
+   struct OOAliases *aliases;
+   OOBOOL fwdedByRemote; /*Set when we are being fwded by remote*/
+} OOCallFwdData;      
+
+/**
+ * Structure to store information on an H.323 channel (H.225 or H.245) for 
+ * a particular call.
+ */
+typedef struct OOH323Channel {
+   OOSOCKET sock;      /*!< Socket connection for the channel */
+   int      port;      /*!< Port assigned to the channel */
+   DList    outQueue;  /*!< Output message queue */
+} OOH323Channel;
+
+/**
+ * Structure to store information on fast start response (H.225) to 
+ * reply same answer in CALL PROCEEDING, ALERTING & CONNECT.
+ */
+typedef struct EXTERN FastStartResponse {
+   ASN1UINT n;
+   ASN1DynOctStr *elem;
+} FastStartResponse;
+
+
+/**
+ * This structure is used to maintain all information on an active call. 
+ * A list of these structures is maintained within the global endpoint 
+ * structure.
+ */
+typedef struct OOH323CallData {
+   OOCTXT               *pctxt;
+   char                 callToken[20]; /* ex: ooh323c_call_1 */
+   char                 callType[10]; /* incoming/outgoing */
+   OOCallMode           callMode;
+   ASN1USINT            callReference;
+   char                 ourCallerId[256];
+   H225CallIdentifier   callIdentifier;/* The call identifier for the active 
+                                          call. */
+   char                 *callingPartyNumber;
+   char                 *calledPartyNumber; 
+   H225ConferenceIdentifier confIdentifier;
+   ASN1UINT             flags;
+   OOCallState          callState;
+   OOCallClearReason    callEndReason;
+   unsigned             h245ConnectionAttempts;
+   OOH245SessionState   h245SessionState;
+   int                  dtmfmode;
+   OOMediaInfo          *mediaInfo;
+   OOCallFwdData        *pCallFwdData;
+   char                 localIP[20];/* Local IP address */
+   OOH323Channel*       pH225Channel;
+   OOH323Channel*       pH245Channel;
+   OOSOCKET             *h245listener;
+   int                  *h245listenport;
+   char                 remoteIP[20];/* Remote IP address */
+   int                  remotePort;
+   int                  remoteH245Port;
+   char                 *remoteDisplayName;
+   struct OOAliases     *remoteAliases;
+   struct OOAliases     *ourAliases; /*aliases used in the call for us */
+   OOMasterSlaveState   masterSlaveState;   /*!< Master-Slave state */ 
+   ASN1UINT             statusDeterminationNumber;
+   OOCapExchangeState   localTermCapState;
+   OOCapExchangeState   remoteTermCapState;
+   struct ooH323EpCapability* ourCaps;
+   struct ooH323EpCapability* remoteCaps; /* TODO: once we start using jointCaps, get rid of remoteCaps*/
+   struct ooH323EpCapability* jointCaps;
+   int                  jointDtmfMode;
+   DList                remoteFastStartOLCs;
+   ASN1UINT8            remoteTermCapSeqNo;
+   ASN1UINT8            localTermCapSeqNo;
+   OOCapPrefs           capPrefs;   
+   OOLogicalChannel*    logicalChans; 
+   int                  noOfLogicalChannels;
+   int                  logicalChanNoBase;
+   int                  logicalChanNoMax;
+   int                  logicalChanNoCur;
+   unsigned             nextSessionID; /* Note by default 1 is audio session, 2 is video and 3 is data, from 3 onwards master decides*/
+   DList                timerList;
+   ASN1UINT             msdRetries;
+   FastStartResponse    *pFastStartRes; /* fast start response */
+   void                 *usrData; /*!<User can set this to user specific data*/
+   struct OOH323CallData* next;
+   struct OOH323CallData* prev;
+} OOH323CallData;
+
+#define ooCallData OOH323CallData
+
+/**
+ * This callback function is triggered when a new call structure is 
+ * created inside the stack for an incoming or outgoing call.
+ *
+ * @param call H.323 call data structure
+ * @return 0 if callback was successful, non-zero error code if failure.
+ */
+typedef int (*cb_OnNewCallCreated)(OOH323CallData* call);
+
+/**
+ * This callback function is triggered when a Q.931 alerting message is 
+ * received for an outgoing call or when a Q.931 alerting message is sent 
+ * for an incoming call.
+ *
+ * @param call H.323 call data structure
+ * @return 0 if callback was successful, non-zero error code if failure.
+ */
+typedef int (*cb_OnAlerting)(OOH323CallData * call);
+
+/**
+ * This callback function is triggered when there is an incoming call. 
+ * In the case where a gatekeeper is in use, the call must first be 
+ * admitted by the gatekeeper before this callback is triggered.
+ *
+ * @param call H.323 call data structure
+ * @return 0 if callback was successful, non-zero error code if failure.
+ */
+typedef int (*cb_OnIncomingCall)(OOH323CallData* call );
+
+/**
+ * This callback function is triggered after a Q.931 setup message 
+ * is sent for an outgoing call.
+ *
+ * @param call H.323 call data structure
+ * @return 0 if callback was successful, non-zero error code if failure.
+ */
+typedef int (*cb_OnOutgoingCall)(OOH323CallData* call );
+
+/**
+ * This callback function is triggered when a Q.931 connect message is 
+ * sent in case of incoming call.  In case of outgoing call, this is invoked 
+ * when a Q.931 connect message is received. It is not invoked until after 
+ * fast start and H.245 tunneling messages within the connect message are 
+ * processed.
+ *
+ * @param call H.323 call data structure
+ * @return 0 if callback was successful, non-zero error code if failure.
+ */
+typedef int (*cb_OnCallEstablished)(struct OOH323CallData* call);
+
+/**
+ * This callback function is triggered when a call is cleared.
+ *
+ * @param call H.323 call data structure
+ * @return 0 if callback was successful, non-zero error code if failure.
+ */
+typedef int (*cb_OnCallCleared)(struct OOH323CallData* call);
+
+/**
+ * This callback function is triggered when master-slave determination 
+ * and capabilities negotiation procedures are successfully completed 
+ * for a call.
+ *
+ * @param call H.323 call data structure
+ * @return 0 if callback was successful, non-zero error code if failure.
+ */
+typedef int (*cb_OpenLogicalChannels)(struct OOH323CallData* call);
+
+/**
+ * This callback function is triggered when a call is forwarded by
+ * a remote endpoint to another remote destination.
+ * @param call Associated H.323 call data structure
+ * @return 0 if callback was successful, non-zero error code if failure
+ */
+typedef int (*cb_OnCallForwarded)(struct OOH323CallData* call);
+
+/**
+ * This callback function is triggered when dtmf is received over Q.931(keypad)
+ * or H.245(alphanumeric) or H.245(signal). This is not triggered when rfc
+ * 2833 based dtmf is received.
+ */
+typedef int (*cb_OnReceivedDTMF)
+   (struct OOH323CallData *call, const char *dtmf);
+
+/**
+ * This structure holds all of the H.323 signaling callback function 
+ * addresses.
+ * @see ooH323EpSetH323Callbacks
+ */
+typedef struct OOH323CALLBACKS {
+   cb_OnAlerting onNewCallCreated;
+   cb_OnAlerting onAlerting;
+   cb_OnIncomingCall onIncomingCall;
+   cb_OnOutgoingCall onOutgoingCall;
+   cb_OnCallEstablished onCallEstablished;
+   cb_OnCallForwarded onCallForwarded;
+   cb_OnCallCleared onCallCleared;
+   cb_OpenLogicalChannels openLogicalChannels;
+   cb_OnReceivedDTMF onReceivedDTMF;
+} OOH323CALLBACKS;
+
+/**
+ * This function is used to create a new call entry.
+ * @param type         Type of the call (incoming/outgoing)
+ * @param callToken    Call Token, an uniques identifier for the call
+ *
+ * @return             Pointer to a newly created call
+ */
+EXTERN OOH323CallData* ooCreateCall(char *type, char *callToken);
+
+/**
+ * This function is used to add a call to the list of existing calls.
+ * @param call         Pointer to the call to be added.
+ * @return             OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooAddCallToList (OOH323CallData *call);
+
+/**
+ * This function is used to set the caller ID for a call.
+ *
+ * @param call          Handle to the call
+ * @param callerid      caller ID value
+ * @return              OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooCallSetCallerId
+(OOH323CallData* call, const char* callerid);
+
+/**
+ * This function is used to set calling party number for a particular call.
+ * @param call          Handle to the call.
+ * @param number        Calling Party number value.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallSetCallingPartyNumber
+(OOH323CallData *call, const char *number);
+
+/**
+ * This function is used to retrieve calling party number of a particular call.
+ * @param call          Handle to the call.
+ * @param buffer        Handle to the buffer in which value will be returned.
+ * @param len           Length of the supplied buffer.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallGetCallingPartyNumber
+(OOH323CallData *call, char *buffer, int len);
+
+/**
+ * This function is used to retrieve called party number of a particular call.
+ * @param call          Handle to the call.
+ * @param buffer        Handle to the buffer in which value will be returned.
+ * @param len           Length of the supplied buffer.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallGetCalledPartyNumber
+(OOH323CallData *call, char *buffer, int len);
+
+/**
+ * This function is used to set called party number for a particular call.
+ * @param call          Handle to the call.
+ * @param number        Called Party number value.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallSetCalledPartyNumber
+(OOH323CallData *call, const char *number);
+
+/**
+ * This function is used to clear the local aliases used by this call.
+ * @param call          Handle to the call.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallClearAliases(OOH323CallData *call);
+
+/**
+ * This function is used to add an H323ID alias to be used by local endpoint 
+ * for a particular call.
+ * @param call          Handle to the call
+ * @param h323id        H323ID to add for the local endpoint for the call.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallAddAliasH323ID(OOH323CallData *call, const char* h323id);
+
+/**
+ * This function is used to add an dialedDigits alias to be used by local 
+ * endpoint for a particular call.
+ * @param call          Handle to the call
+ * @param dialedDigits  DialedDigits to add for the local endpoint for call.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallAddAliasDialedDigits
+                             (OOH323CallData *call, const char* dialedDigits);
+
+/**
+ * This function is used to add an email-id alias to be used by local 
+ * endpoint for a particular call.
+ * @param call          Handle to the call
+ * @param email         Email-id to add for the local endpoint for call.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallAddAliasEmailID(OOH323CallData *call, const char* email);
+
+
+/**
+ * This function is used to add an email-id alias to be used by local 
+ * endpoint for a particular call.
+ * @param call          Handle to the call
+ * @param url           URL-id to add for the local endpoint for call.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallAddAliasURLID(OOH323CallData *call, const char* url);
+
+
+/**
+ * This is a helper function used by other call related add aliases functions 
+ * to add a particular alias. This function is not supposed to be called 
+ * directly.
+ * @param call          Handle to the call
+ * @param aliasType     Type of alias being added
+ * @param value         Alias value
+ * @param local         Whether alias is for local party or remote party
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooCallAddAlias
+   (OOH323CallData *call, int aliasType, const char *value, OOBOOL local);
+
+
+/**
+ * This function is used to add an dialed digits alias for the remote endpoint 
+ * involved in a particular call.
+ * @param call          Handle to the call
+ * @param dialedDigits  dialedDigits alias to add for the remote endpoint.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallAddRemoteAliasDialedDigits
+   (OOH323CallData *call, const char* dialedDigits);
+
+/**
+ * This function is used to add an H323ID alias for the remote endpoint 
+ * involved in a particular call.
+ * @param call          Handle to the call
+ * @param h323id        H323ID to add for the remote endpoint.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCallAddRemoteAliasH323ID(OOH323CallData *call, const char* h323id);
+
+
+/**
+ * This function is used to add G7231 capability for the call. The 
+ * "ooCallAdd...Capability" functions allow to override the global endpoint 
+ * capabilities and use specific capabilities for specific calls.
+ * @param call                 Call for which capability has to be added.
+ * @param cap                  Capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param silenceSuppression   Indicates support for silenceSuppression.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooCallAddG7231Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, OOBOOL silenceSuppression, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel);
+
+/**
+ * This function is used to add G728 capability for the call. The 
+ * "ooCallAdd...Capability" functions allow to override the global endpoint 
+ * capabilities and use specific capabilities for specific calls.
+ * @param call                 Call for which capability has to be added.
+ * @param cap                  Capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooCallAddG728Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel);
+
+/**
+ * This function is used to add G729 capability for the call. The 
+ * "ooCallAdd...Capability" functions allow to override the global endpoint 
+ * capabilities and use specific capabilities for specific calls.
+ * @param call                 Call for which capability has to be added.
+ * @param cap                  Capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooCallAddG729Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel);
+
+/**
+ * This function is used to add G711 capability for the call. The 
+ * "ooCallAdd...Capability" functions allow to override the global endpoint 
+ * capabilities and use specific capabilities for specific calls.
+ * @param call                 Call for which capability has to be added.
+ * @param cap                  Capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooCallAddG711Capability(OOH323CallData *call, int cap, int txframes, 
+                            int rxframes, int dir,
+                            cb_StartReceiveChannel startReceiveChannel,
+                            cb_StartTransmitChannel startTransmitChannel,
+                            cb_StopReceiveChannel stopReceiveChannel,
+                            cb_StopTransmitChannel stopTransmitChannel);
+
+
+/**
+ * This function is used to add GSM capability for the call. The 
+ * "ooCallAdd...Capability" functions allow to override the global endpoint 
+ * capabilities and use specific capabilities for specific calls.
+ * @param call                 Call for which capability has to be added.
+ * @param cap                  Type of GSM capability to be added.
+ * @param framesPerPkt         Number of GSM frames pre packet. 
+ * @param comfortNoise         Comfort noise spec for the capability. 
+ * @param scrambled            Scrambled enabled/disabled for the capability.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooCallAddGSMCapability(OOH323CallData* call, int cap, 
+                                  ASN1USINT framesPerPkt, OOBOOL comfortNoise, 
+                                  OOBOOL scrambled, int dir,
+                                  cb_StartReceiveChannel startReceiveChannel,
+                                  cb_StartTransmitChannel startTransmitChannel,
+                                  cb_StopReceiveChannel stopReceiveChannel,
+                                  cb_StopTransmitChannel stopTransmitChannel);
+
+
+
+
+/**
+ * This function is used to add H263 video capability for the call. The 
+ * "ooCallAdd...Capability" functions allow to override the global endpoint 
+ * capabilities and use specific capabilities for specific calls.
+ * @param call                 Call for which capability has to be added.
+ * @param cap                  Capability type - OO_H263VIDEO
+ * @param sqcifMPI             Minimum picture interval for encoding/decoding 
+ *                             of SQCIF pictures.
+ * @param qcifMPI              Minimum picture interval for encoding/decoding 
+ *                             of QCIF pictures.
+ * @param cifMPI               Minimum picture interval for encoding/decoding 
+ *                             of CIF pictures.
+ * @param cif4MPI              Minimum picture interval for encoding/decoding 
+ *                             of CIF4 pictures.
+ * @param cif16MPI             Minimum picture interval for encoding/decoding 
+ *                             of CIF16 pictures.
+ * @param maxBitRate           Maximum bit rate in units of 100 bits/s at
+ *                             which a transmitter can transmit video or a 
+ *                             receiver can receive video.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooCallAddH263VideoCapability(OOH323CallData *call, int cap, 
+                                 unsigned sqcifMPI, unsigned qcifMPI, 
+                                 unsigned cifMPI, unsigned cif4MPI, 
+                                 unsigned cif16MPI, unsigned maxBitRate, 
+                                 int dir, 
+                                 cb_StartReceiveChannel startReceiveChannel,
+                                 cb_StartTransmitChannel startTransmitChannel,
+                                 cb_StopReceiveChannel stopReceiveChannel,
+                                 cb_StopTransmitChannel stopTransmitChannel);
+
+
+/**
+ * This function is used to enable rfc 2833 capability for the call. By default
+ * the stack uses the dtmf settings for the endpoint. But if you want to
+ * enable/disable dtmf for a specific call, then you can override end-point
+ * settings using this function
+ * @param call                  Call for which rfc2833 has to be enabled.
+ * @param dynamicRTPPayloadType dynamicRTPPayloadType to be used.
+ *
+ * @return                      OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallEnableDTMFRFC2833
+          (OOH323CallData *call, int dynamicRTPPayloadType);
+
+
+/**
+ * This function is used to disable rfc 2833 capability for the call. 
+ * By default the stack uses the dtmf settings for the endpoint. But if you 
+ * want to enable/disable dtmf for a specific call, then you can override 
+ * end-point settings using this function
+ * @param call                  Call for which rfc2833 has to be disabled.
+ *
+ * @return                      OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallDisableDTMFRFC2833(OOH323CallData *call);
+
+
+/**
+ * This function is used to enable H.245(alphanumeric) dtmf support for the 
+ * call. By default the stack uses the dtmf settings for the endpoint. But if 
+ * you want to enable H.245(alphanumeric) dtmf for a specific call, then you 
+ * can override end-point settings using this function
+ * @param call                  Call for which H.245(alphanumeric) dtmf support
+ *                              has to be enabled.
+ *
+ * @return                      OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallEnableDTMFH245Alphanumeric(OOH323CallData *call);
+
+/**
+ * This function is used to disable H.245(alphanumeric) dtmf support for the 
+ * call. By default the stack uses the dtmf settings for the endpoint. But if 
+ * you want to disable H.245(alphanumeric) dtmf for a specific call, then you 
+ * can override end-point settings using this function
+ * @param call                  Call for which H.245(alphanumeric) dtmf support
+ *                              has to be disabled.
+ *
+ * @return                      OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallDisableDTMFH245Alphanumeric(OOH323CallData *call);
+
+/**
+ * This function is used to enable H.245(signal) dtmf support for the call. 
+ * By default the stack uses the dtmf settings for the endpoint. But if you 
+ * want to enable H.245(signal) dtmf for a specific call, then you can override
+ * end-point settings using this function
+ * @param call                  Call for which H.245(signal) dtmf support
+ *                              has to be enabled.
+ *
+ * @return                      OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallEnableDTMFH245Signal(OOH323CallData *call);
+
+
+/**
+ * This function is used to disable H.245(signal) dtmf support for the call. 
+ * By default the stack uses the dtmf settings for the endpoint. But if you 
+ * want to disable H.245(signal) dtmf for a specific call, then you can 
+ * override end-point settings using this function
+ * @param call                  Call for which H.245(signal) dtmf support
+ *                              has to be disabled.
+ *
+ * @return                      OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallDisableDTMFH245Signal(OOH323CallData *call);
+
+
+/**
+ * This function is used to enable Q.931(keypad) dtmf support for the call.
+ * By default the stack uses the dtmf settings for the endpoint. But if you 
+ * want to enable Q.931(keypad) dtmf support for a specific call, then you can
+ * override end-point settings using this function
+ * @param call                  Call for which Q.931(keypad) dtmf support
+ *                              has to be enabled.
+ *
+ * @return                      OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallEnableDTMFQ931Keypad(OOH323CallData *call);
+
+/**
+ * This function is used to disable Q.931(keypad) dtmf support for the call.
+ * By default the stack uses the dtmf settings for the endpoint. But if you 
+ * want to disable Q.931(keypad) dtmf support for a specific call, then you can
+ * override end-point settings using this function
+ * @param call                  Call for which Q.931(keypad) dtmf support
+ *                              has to be disabled.
+ *
+ * @return                      OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallDisableDTMFQ931Keypad(OOH323CallData *call);
+
+
+/**
+ * This function is used to find a call by using the unique token for the call.
+ * @param callToken      The unique token for the call.
+ *
+ * @return               Pointer to the call if found, NULL otherwise.
+ */
+EXTERN OOH323CallData* ooFindCallByToken(char *callToken);
+
+/**
+ * This function is used to end a call. Based on what stage of clearance the
+ * call is it takes appropriate action.
+ *
+ * @param call   Handle to the call which has to be cleared.
+ * @return       OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooEndCall(OOH323CallData *call);
+
+/**
+ * This function is used to remove a call from the list of existing calls.
+ * 
+ * @param call          Pointer to the call to be removed.
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooRemoveCallFromList (OOH323CallData *call);
+
+/**
+ * This function is used to clean up a call. It closes all associated sockets, 
+ * removes the call from the global list and frees up associated memory.
+ *
+ * @param call          Pointer to the call to be cleared.
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCleanCall(OOH323CallData *call);
+
+/**
+ * This function is used to check whether a specified session in specified 
+ * direction is active for the call.
+ * @param call       Handle to call for which session has to be queried.
+ * @param sessionID  Session id to identify the type of session(1 for audio, 
+ *                   2 for voice and 3 for data)
+ * @param dir        Direction of the session(transmit/receive)
+ *
+ * @return           1, if session active. 0, otherwise. 
+ */
+EXTERN ASN1BOOL ooIsSessionEstablished
+(OOH323CallData *call, int sessionID, char* dir);
+
+/**
+ * This function can be used by an application to specify media endpoint 
+ * information for different types of media. The stack by default uses local IP
+ * and port for media. An application can provide mediainfo if it wants to 
+ * override default.
+ * @param call      Handle to the call
+ * @param mediaInfo Structure which defines the media endpoint to be 
+ *                  used.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooAddMediaInfo(OOH323CallData *call, OOMediaInfo mediaInfo);
+
+/**
+ * This function is used to generate a media session id for the new media 
+ * session for the call.
+ * @param call       Handle to the call.
+ * @param type       Type of media session.
+ * @param dir        Direction of session
+ *
+ * @return           Generated session id.
+ */
+EXTERN unsigned ooCallGenerateSessionID
+                    (OOH323CallData *call, OOCapType type, char *dir);
+
+/**
+ * This is an handler for H245 connection retry timer. When remote end is not 
+ * yet listening for H245 connections, this timer provides a wait and retry
+ * mechanism to establish H245 connection.
+ * @param data      Timer callback data.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooCallH245ConnectionRetryTimerExpired(void *data);
+
+/**
+ * This function is used to retrieve the description text for a reason
+ * code.
+ *
+ * @param code     Reason code.
+ * @return         The text description string.
+ */
+EXTERN const char* ooGetReasonCodeText (OOUINT32 code);
+
+/**
+ * This function is used to retrieve the description text for a call
+ * state.
+ *
+ * @param callState Call state.
+ * @return         The text description string.
+ */
+EXTERN const char* ooGetCallStateText (OOCallState callState);
+
+/** 
+ * @} 
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/ooCapability.c b/addons/ooh323c/src/ooCapability.c
new file mode 100644
index 000000000..aeecbee10
--- /dev/null
+++ b/addons/ooh323c/src/ooCapability.c
@@ -0,0 +1,2349 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+#include "ooCapability.h"
+#include "ootrace.h"
+#include "ooCalls.h"
+#include "ooh323ep.h"
+#include "ooUtils.h"
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+static int giDynamicRTPPayloadType = 101;
+
+int ooCapabilityEnableDTMFRFC2833
+   (OOH323CallData *call, int dynamicRTPPayloadType)
+{
+   if(!call)
+   {
+      gH323ep.dtmfmode |= OO_CAP_DTMF_RFC2833;
+      OOTRACEINFO1("Enabled RFC2833 DTMF capability for end-point\n");
+   }
+   else{
+      call->dtmfmode |= OO_CAP_DTMF_RFC2833;
+      OOTRACEINFO3("Enabled RFC2833 DTMF capability for (%s, %s) \n", 
+                   call->callType, call->callToken);
+   }
+
+   /*Dynamic RTP payload type range is from 96 - 127 */
+   if(dynamicRTPPayloadType >= 96 && dynamicRTPPayloadType <= 127)
+      giDynamicRTPPayloadType = dynamicRTPPayloadType;
+
+   return OO_OK;
+}
+
+
+
+int ooCapabilityDisableDTMFRFC2833(OOH323CallData *call)
+{
+   if(!call){
+      gH323ep.dtmfmode ^= OO_CAP_DTMF_RFC2833;
+      OOTRACEINFO1("Disabled RFC2833 DTMF capability for end-point\n");
+   }
+   else{
+      call->dtmfmode ^= OO_CAP_DTMF_RFC2833;
+      OOTRACEINFO3("Disabled RFC2833 DTMF capability for (%s, %s)\n", 
+                    call->callType, call->callToken);
+   }
+
+   return OO_OK;
+}
+
+int ooCapabilityEnableDTMFH245Alphanumeric(OOH323CallData *call)
+{
+   if(!call){
+      gH323ep.dtmfmode |= OO_CAP_DTMF_H245_alphanumeric;
+      OOTRACEINFO1("Dtmf mode set to H.245(alphanumeric) for endpoint\n");
+   }
+   else {
+      call->dtmfmode |= OO_CAP_DTMF_H245_alphanumeric;
+      OOTRACEINFO3("Dtmf mode set to H.245(alphanumeric) for (%s, %s)\n", 
+                    call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooCapabilityDisableDTMFH245Alphanumeric(OOH323CallData *call)
+{
+   if(!call){
+      gH323ep.dtmfmode ^= OO_CAP_DTMF_H245_alphanumeric;
+      OOTRACEINFO1("Dtmf mode H.245(alphanumeric) disabled for endpoint\n");
+   }
+   else {
+      call->dtmfmode ^= OO_CAP_DTMF_H245_alphanumeric;
+      OOTRACEINFO3("Dtmf mode H.245(alphanumeric) disabled for (%s, %s)\n", 
+                    call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooCapabilityEnableDTMFH245Signal(OOH323CallData *call)
+{
+   if(!call){
+      gH323ep.dtmfmode |= OO_CAP_DTMF_H245_signal;
+      OOTRACEINFO1("Dtmf mode set to H.245(signal) for endpoint\n");
+   }
+   else {
+      call->dtmfmode |= OO_CAP_DTMF_H245_signal;
+      OOTRACEINFO3("Dtmf mode set to H.245(signal) for (%s, %s)\n", 
+                    call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooCapabilityDisableDTMFH245Signal(OOH323CallData *call)
+{
+   if(!call){
+      gH323ep.dtmfmode ^= OO_CAP_DTMF_H245_signal;
+      OOTRACEINFO1("Dtmf mode H.245(signal) disabled for endpoint\n");
+   }
+   else {
+      call->dtmfmode ^= OO_CAP_DTMF_H245_signal;
+      OOTRACEINFO3("Dtmf mode H.245(signal) disabled for (%s, %s)\n", 
+                    call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooCapabilityEnableDTMFQ931Keypad(struct OOH323CallData *call)
+{
+   if(!call){
+      gH323ep.dtmfmode |= OO_CAP_DTMF_Q931;
+      OOTRACEINFO1("Dtmf mode set to Q.931(keypad) for the endpoint\n");
+   }
+   else {
+      call->dtmfmode |= OO_CAP_DTMF_Q931;
+      OOTRACEINFO3("Dtmf mode set to Q.931(keypad) for the call (%s, %s)\n", 
+                    call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooCapabilityDisableDTMFQ931Keypad(struct OOH323CallData *call)
+{
+   if(!call){
+      gH323ep.dtmfmode ^= OO_CAP_DTMF_Q931;
+      OOTRACEINFO1("Dtmf mode Q.931(keypad) disabled for the endpoint\n");
+   }
+   else {
+      call->dtmfmode ^= OO_CAP_DTMF_Q931;
+      OOTRACEINFO3("Dtmf mode Q.931(keypad) disabled for the call (%s, %s)\n", 
+                    call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooCapabilityAddH263VideoCapability(ooCallData *call, 
+                              unsigned sqcifMPI, unsigned qcifMPI, 
+                              unsigned cifMPI, unsigned cif4MPI, 
+                              unsigned cif16MPI, unsigned maxBitRate, int dir, 
+                              cb_StartReceiveChannel startReceiveChannel,
+                              cb_StartTransmitChannel startTransmitChannel,
+                              cb_StopReceiveChannel stopReceiveChannel,
+                              cb_StopTransmitChannel stopTransmitChannel, 
+                              OOBOOL remote)
+{
+   int ret = OO_OK;
+   if(sqcifMPI>0)
+   {
+      ret = ooCapabilityAddH263VideoCapability_helper(call, sqcifMPI, 0, 
+                                 0, 0, 0, maxBitRate, dir, startReceiveChannel,
+                                 startTransmitChannel, stopReceiveChannel,
+                                 stopTransmitChannel, remote);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR1("Error: Failed to add H263 sqcifMPI capability\n");
+         return OO_FAILED;
+      }
+   }
+   if(qcifMPI>0)
+   {
+      ret = ooCapabilityAddH263VideoCapability_helper(call, 0, qcifMPI, 0,
+                                 0, 0, maxBitRate, dir, startReceiveChannel,
+                                 startTransmitChannel, stopReceiveChannel,
+                                 stopTransmitChannel, remote);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR1("Error: Failed to add H263 qcifMPI capability\n");
+         return OO_FAILED;
+      }
+   }
+   if(cifMPI>0)
+   {
+      ret = ooCapabilityAddH263VideoCapability_helper(call, 0, 0, cifMPI, 
+                                 0, 0, maxBitRate, dir, startReceiveChannel,
+                                 startTransmitChannel, stopReceiveChannel,
+                                 stopTransmitChannel, remote);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR1("Error: Failed to add H263 cifMPI capability\n");
+         return OO_FAILED;
+      }
+   }
+   if(cif4MPI>0)
+   {
+      ret = ooCapabilityAddH263VideoCapability_helper(call, 0, 0, 0, 
+                                 cif4MPI, 0, maxBitRate, dir, 
+                                 startReceiveChannel,
+                                 startTransmitChannel, stopReceiveChannel,
+                                 stopTransmitChannel, remote);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR1("Error: Failed to add H263 cif4MPI capability\n");
+         return OO_FAILED;
+      }
+   }
+   if(cif16MPI>0)
+   {
+      ret = ooCapabilityAddH263VideoCapability_helper(call, dir, 0, 0, 0, 0, 
+                                 cif16MPI, maxBitRate, startReceiveChannel,
+                                 startTransmitChannel, stopReceiveChannel,
+                                 stopTransmitChannel, remote);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR1("Error: Failed to add H263 cif16MPI capability\n");
+         return OO_FAILED;
+      }
+   }
+   return OO_OK;
+
+}
+
+int ooCapabilityAddH263VideoCapability_helper(ooCallData *call,
+                              unsigned sqcifMPI, unsigned qcifMPI, 
+                              unsigned cifMPI, unsigned cif4MPI, 
+                              unsigned cif16MPI, unsigned maxBitRate, int dir, 
+                              cb_StartReceiveChannel startReceiveChannel,
+                              cb_StartTransmitChannel startTransmitChannel,
+                              cb_StopReceiveChannel stopReceiveChannel,
+                              cb_StopTransmitChannel stopTransmitChannel, 
+                              OOBOOL remote)
+{
+
+   ooH323EpCapability *epCap = NULL, *cur=NULL;
+   OOH263CapParams *params=NULL;   
+   OOCTXT *pctxt=NULL;
+   char *pictureType = NULL;
+   int cap = OO_H263VIDEO;
+
+   if(!call) pctxt = &gH323ep.ctxt;
+   else pctxt = call->pctxt;
+
+   epCap = (ooH323EpCapability*)memAllocZ(pctxt, sizeof(ooH323EpCapability));
+   params = (OOH263CapParams*) memAllocZ(pctxt, sizeof(OOH263CapParams));
+   if(!epCap || !params)
+   {
+      OOTRACEERR1("Error:Memory - ooCapabilityAddH263Capability - epCap/params"
+                  ".\n");
+      return OO_FAILED;
+   }
+   
+   if(sqcifMPI>0)
+   {
+      params->MPI = sqcifMPI;
+      params->picFormat = OO_PICFORMAT_SQCIF;
+      pictureType = "SQCIF";
+   }
+   if(qcifMPI>0)
+   {
+      params->MPI = qcifMPI;
+      params->picFormat =  OO_PICFORMAT_QCIF;
+      pictureType = "QCIF";
+   }
+   if(cifMPI>0)
+   {
+      params->MPI = cifMPI;
+      params->picFormat = OO_PICFORMAT_CIF;
+      pictureType = "CIF";
+   }
+   if(cif4MPI>0)
+   {
+      params->MPI = cif4MPI;
+      params->picFormat = OO_PICFORMAT_CIF4;
+      pictureType = "CIF4";
+   }
+   if(cif16MPI>0)
+   {
+      params->MPI = cif16MPI;
+      params->picFormat = OO_PICFORMAT_CIF16;
+      pictureType = "CIF16";
+   }
+
+   params->maxBitRate = maxBitRate;
+
+
+   if(dir & OORXANDTX)
+   {
+      epCap->dir = OORX;
+      epCap->dir |= OOTX;
+   }
+   else
+      epCap->dir = dir;
+   
+   epCap->cap = OO_H263VIDEO;
+   epCap->capType = OO_CAP_TYPE_VIDEO;
+   epCap->params = (void*)params;
+   epCap->startReceiveChannel = startReceiveChannel;
+   epCap->startTransmitChannel = startTransmitChannel;
+   epCap->stopReceiveChannel = stopReceiveChannel;
+   epCap->stopTransmitChannel = stopTransmitChannel;
+   
+   epCap->next = NULL;
+
+   if(!call)
+   {/*Add as local capability */
+      OOTRACEDBGC2("Adding endpoint H263 video capability %s.\n", pictureType);
+      if(!gH323ep.myCaps)
+         gH323ep.myCaps = epCap;
+      else{
+         cur = gH323ep.myCaps;
+         while(cur->next) cur = cur->next;
+         cur->next = epCap;
+      }
+      ooAppendCapToCapPrefs(NULL, cap);
+      gH323ep.noOfCaps++;
+   }
+   else{
+      if(remote)
+      {
+         /*Add as remote capability */
+         if(!call->remoteCaps)
+            call->remoteCaps = epCap;
+         else{
+            cur = call->remoteCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+     }
+     else{
+        /*Add as our capability */
+        OOTRACEDBGC4("Adding call specific H263 video capability %s. "
+                     "(%s, %s)\n", pictureType, call->callType, 
+                     call->callToken);
+        if(!call->ourCaps){
+           call->ourCaps = epCap;
+           ooResetCapPrefs(call);
+        }
+        else{
+           cur = call->ourCaps;
+           while(cur->next) cur = cur->next;
+           cur->next = epCap;
+        }
+        ooAppendCapToCapPrefs(call, cap);
+     }
+   }
+
+   return OO_OK;
+}
+
+/* Used for g711 ulaw/alaw, g728, g729 and g7231 */
+int ooCapabilityAddSimpleCapability
+   (OOH323CallData *call, int cap, int txframes, 
+    int rxframes, OOBOOL silenceSuppression, int dir, 
+    cb_StartReceiveChannel startReceiveChannel,
+    cb_StartTransmitChannel startTransmitChannel,
+    cb_StopReceiveChannel stopReceiveChannel,
+    cb_StopTransmitChannel stopTransmitChannel,
+    OOBOOL remote)
+{
+   ooH323EpCapability *epCap = NULL, *cur=NULL;
+   OOCapParams *params=NULL;   
+   OOCTXT *pctxt=NULL;
+   if(!call) pctxt = &gH323ep.ctxt;
+   else pctxt = call->pctxt;
+
+   epCap = (ooH323EpCapability*)memAlloc(pctxt, sizeof(ooH323EpCapability));
+   params = (OOCapParams*) memAlloc(pctxt, sizeof(OOCapParams));
+   if(!epCap || !params)
+   {
+      OOTRACEERR1("ERROR: Memory - ooCapabilityAddSimpleCapability - "
+                  "epCap/params\n");
+      return OO_FAILED;
+   }
+
+
+   params->txframes = txframes;
+   params->rxframes = rxframes;
+   /* Ignore silence suppression parameter unless cap is g7231 */
+   if(cap == OO_G7231)
+      params->silenceSuppression = silenceSuppression;
+   else
+      params->silenceSuppression = FALSE; /* Set to false for g711 and g729*/
+
+   if(dir & OORXANDTX) {
+      epCap->dir = OORX;
+      epCap->dir |= OOTX;
+   }
+   else {
+      epCap->dir = dir;
+   }
+   
+   epCap->cap = cap;
+   epCap->capType = OO_CAP_TYPE_AUDIO;
+   epCap->params = (void*)params;
+   epCap->startReceiveChannel = startReceiveChannel;
+   epCap->startTransmitChannel = startTransmitChannel;
+   epCap->stopReceiveChannel = stopReceiveChannel;
+   epCap->stopTransmitChannel = stopTransmitChannel;
+   epCap->next = NULL;
+
+   if(!call)
+   {
+      /* Add as local capability */
+      OOTRACEDBGC2("Adding endpoint capability %s. \n", 
+                     ooGetCapTypeText(epCap->cap));
+      if(!gH323ep.myCaps) {
+         gH323ep.myCaps = epCap;
+      }
+      else{
+         cur = gH323ep.myCaps;
+         while(cur->next) cur = cur->next;
+         cur->next = epCap;
+      }
+      ooAppendCapToCapPrefs(NULL, cap);
+      gH323ep.noOfCaps++;
+   }
+   else{
+      if(remote)
+      {
+         /* Add as remote capability */
+         if(!call->remoteCaps) {
+            call->remoteCaps = epCap;
+         }
+         else{
+            cur = call->remoteCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+      }
+      else{
+         /* Add as our capability */
+         OOTRACEDBGC4("Adding call specific capability %s. (%s, %s)\n", 
+                      ooGetCapTypeText(epCap->cap), call->callType, 
+                      call->callToken);
+         if(!call->ourCaps){
+            call->ourCaps = epCap;
+            ooResetCapPrefs(call);
+         }
+         else{
+            cur = call->ourCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+         ooAppendCapToCapPrefs(call, cap);
+      }
+   }
+           
+   return OO_OK;
+}
+
+
+int ooCapabilityAddGSMCapability(OOH323CallData *call, int cap, 
+                                unsigned framesPerPkt, OOBOOL comfortNoise,
+                                OOBOOL scrambled, int dir, 
+                                cb_StartReceiveChannel startReceiveChannel,
+                                cb_StartTransmitChannel startTransmitChannel,
+                                cb_StopReceiveChannel stopReceiveChannel,
+                                cb_StopTransmitChannel stopTransmitChannel, 
+                                OOBOOL remote)
+{
+
+   ooH323EpCapability *epCap = NULL, *cur=NULL;
+   OOGSMCapParams *params=NULL;   
+   OOCTXT *pctxt = NULL;
+ 
+   if(!call) pctxt = &gH323ep.ctxt;
+   else pctxt = call->pctxt;
+
+   epCap = (ooH323EpCapability*)memAlloc(pctxt, sizeof(ooH323EpCapability));
+   params = (OOGSMCapParams*) memAlloc(pctxt, sizeof(OOGSMCapParams));
+   if(!epCap || !params)
+   {
+      OOTRACEERR1("Error:Memory - ooCapabilityAddGSMCapability - "
+                  "epCap/params\n");
+      return OO_FAILED;
+   }
+
+
+   params->rxframes = framesPerPkt;
+   params->txframes = framesPerPkt;
+   params->comfortNoise = comfortNoise;
+   params->scrambled = scrambled;
+   if(dir & OORXANDTX)
+   {
+      epCap->dir = OORX;
+      epCap->dir |= OOTX;
+   }
+   else
+      epCap->dir = dir;
+
+   epCap->cap = cap;
+   epCap->capType = OO_CAP_TYPE_AUDIO;
+   epCap->params = (void*)params;
+   epCap->startReceiveChannel = startReceiveChannel;
+   epCap->startTransmitChannel = startTransmitChannel;
+   epCap->stopReceiveChannel = stopReceiveChannel;
+   epCap->stopTransmitChannel = stopTransmitChannel;
+   
+   epCap->next = NULL;
+   /* Add as local capability */
+   if(!call)
+   {
+      if(!gH323ep.myCaps)
+         gH323ep.myCaps = epCap;
+      else{
+         cur = gH323ep.myCaps;
+         while(cur->next) cur = cur->next;
+         cur->next = epCap;
+      }
+      ooAppendCapToCapPrefs(NULL, cap);
+      gH323ep.noOfCaps++;
+   }
+   else{
+      if(remote)
+      {
+         /*Add as remote capability */
+         if(!call->remoteCaps)
+            call->remoteCaps = epCap;
+         else{
+            cur = call->remoteCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+      }
+      else{
+         OOTRACEDBGC4("Adding call specific capability %s. (%s, %s)\n", 
+                     ooGetCapTypeText(epCap->cap), call->callType, 
+                     call->callToken);
+         /*Add as our capability */
+         if(!call->ourCaps){
+            call->ourCaps = epCap;
+            ooResetCapPrefs(call);
+         }
+         else{
+            cur = call->ourCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+         ooAppendCapToCapPrefs(call, cap);
+      }
+   }
+
+   return OO_OK;
+}
+
+
+
+
+struct H245VideoCapability* ooCapabilityCreateVideoCapability
+      (ooH323EpCapability *epCap, OOCTXT *pctxt, int dir)
+{
+
+   if(!epCap)
+   {
+     OOTRACEERR1("Error:Invalid capability parameter passed to "
+                 "ooCapabilityCreateVideoCapability.\n");
+     return NULL;
+   }
+   
+   if(!(epCap->dir & dir))
+   {
+      OOTRACEERR1("Error:Failed to create capability due to direction "
+                  "mismatch.\n");
+      return NULL;
+   }
+
+   switch(epCap->cap)
+   {
+   case OO_H263VIDEO:
+     return ooCapabilityCreateH263VideoCapability(epCap, pctxt, dir);
+
+   case OO_NONSTDVIDEO:
+   case OO_H261VIDEO:
+   case OO_H262VIDEO:
+   case OO_IS11172VIDEO:
+   case OO_GENERICVIDEO:
+   case OO_EXTELEMVIDEO:
+   default:
+      OOTRACEERR2("ERROR: Don't know how to create video capability %s\n",
+                  ooGetCapTypeText(epCap->cap));
+   }
+   return NULL;
+}
+
+
+   
+struct H245AudioCapability* ooCapabilityCreateAudioCapability
+      (ooH323EpCapability *epCap, OOCTXT *pctxt, int dir)
+{
+
+   if(!epCap)
+   {
+     OOTRACEERR1("Error:Invalid capability parameter passed to "
+                 "ooCapabilityCreateAudioCapability.\n");
+     return NULL;
+   }
+   
+   if(!(epCap->dir & dir))
+   {
+      OOTRACEERR1("Error:Failed to create capability due to direction "
+                  "mismatch.\n");
+      return NULL;
+   }
+
+   switch(epCap->cap)
+   {
+   case OO_G711ALAW64K:
+   case OO_G711ALAW56K:
+   case OO_G711ULAW64K:
+   case OO_G711ULAW56K:
+   /*case OO_G726:*/
+   case OO_G728:
+   case OO_G729:
+   case OO_G729A:
+   case OO_G7231:
+     return ooCapabilityCreateSimpleCapability(epCap, pctxt, dir);
+   case OO_GSMFULLRATE:
+      return ooCapabilityCreateGSMFullRateCapability(epCap, pctxt, dir);
+   default:
+      OOTRACEERR2("ERROR: Don't know how to create audio capability %d\n",
+                  epCap->cap);
+   }
+   return NULL;
+}
+
+
+
+void* ooCapabilityCreateDTMFCapability(int cap, OOCTXT *pctxt)
+{
+   H245AudioTelephonyEventCapability *pATECap=NULL;
+   H245UserInputCapability *userInput = NULL;
+   char *events=NULL;
+   switch(cap)
+   {
+   case OO_CAP_DTMF_RFC2833:
+      pATECap = (H245AudioTelephonyEventCapability*)memAlloc(pctxt, 
+                                   sizeof(H245AudioTelephonyEventCapability));
+      if(!pATECap)
+      {
+         OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - pATECap\n");
+         return NULL;
+      }
+      memset(pATECap, 0, sizeof(H245AudioTelephonyEventCapability));
+      pATECap->dynamicRTPPayloadType = giDynamicRTPPayloadType;
+      events = (char*)memAlloc(pctxt, strlen("0-16")+1);
+      if(!events)
+      {
+         OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - events\n");
+         memFreePtr(pctxt, pATECap);
+         return NULL;
+      }
+      strncpy(events, "0-16", strlen("0-16"));
+      pATECap->audioTelephoneEvent = events;
+      return pATECap;
+   case OO_CAP_DTMF_H245_alphanumeric:
+      userInput = (H245UserInputCapability*)memAllocZ(pctxt, 
+                                          sizeof(H245UserInputCapability));
+      if(!userInput)
+      {
+         OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - "
+                     "userInput\n");
+         return NULL;
+      }
+      userInput->t = T_H245UserInputCapability_basicString;
+      return userInput;
+   case OO_CAP_DTMF_H245_signal:
+      userInput = (H245UserInputCapability*)memAllocZ(pctxt, 
+                                          sizeof(H245UserInputCapability));
+      if(!userInput)
+      {
+         OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - "
+                     "userInput\n");
+         return NULL;
+      }
+      userInput->t = T_H245UserInputCapability_dtmf;
+      return userInput;
+   default:
+     OOTRACEERR1("Error:unknown dtmf capability type\n");
+   }
+   return NULL;
+}
+
+
+
+struct H245VideoCapability* ooCapabilityCreateH263VideoCapability
+   (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir)
+{
+   H245VideoCapability *pVideo=NULL;
+   OOH263CapParams *params=NULL;
+   H245H263VideoCapability *pH263Cap=NULL;
+
+   if(!epCap || !epCap->params)
+   {
+     OOTRACEERR1("Error:Invalid capability parameters to "
+                 "ooCapabilityCreateH263VideoCapability.\n");
+     return NULL;
+   }
+   params =(OOH263CapParams*)epCap->params;
+
+   pVideo = (H245VideoCapability*)memAllocZ(pctxt, 
+                                                  sizeof(H245VideoCapability));
+   pH263Cap = (H245H263VideoCapability*) memAllocZ(pctxt, 
+                                             sizeof(H245H263VideoCapability));
+   if(!pVideo || !pH263Cap)
+   {
+      OOTRACEERR1("ERROR:Memory - ooCapabilityCreateH263VideoCapability - "
+                  "pVideo/pH263Cap\n");
+      return NULL;
+   }
+
+   pVideo->t = T_H245VideoCapability_h263VideoCapability;
+   pVideo->u.h263VideoCapability = pH263Cap;
+
+
+   if(params->picFormat ==  OO_PICFORMAT_SQCIF) {
+      pH263Cap->m.sqcifMPIPresent = TRUE;
+      pH263Cap->sqcifMPI = params->MPI;
+   }
+   else if(params->picFormat == OO_PICFORMAT_QCIF) {
+      pH263Cap->m.qcifMPIPresent = TRUE;
+      pH263Cap->qcifMPI = params->MPI;
+   }
+   else if(params->picFormat == OO_PICFORMAT_CIF) {
+      pH263Cap->m.cifMPIPresent = TRUE;
+      pH263Cap->cifMPI = params->MPI;
+   }
+   else if(params->picFormat == OO_PICFORMAT_CIF4) {
+      pH263Cap->m.cif4MPIPresent  = TRUE;
+      pH263Cap->cif4MPI = params->MPI;
+   }
+   else if(params->picFormat == OO_PICFORMAT_CIF16) {
+      pH263Cap->m.cif16MPIPresent = TRUE;
+      pH263Cap->cif16MPI = params->MPI;
+   }
+
+   pH263Cap->m.errorCompensationPresent = TRUE;
+   pH263Cap->maxBitRate = params->maxBitRate;
+   pH263Cap->unrestrictedVector = FALSE;
+   pH263Cap->arithmeticCoding = FALSE;
+   pH263Cap->advancedPrediction = FALSE;
+   pH263Cap->pbFrames = FALSE;
+   pH263Cap->temporalSpatialTradeOffCapability = FALSE;
+   pH263Cap->hrd_B = 0;
+   pH263Cap->bppMaxKb = 0;
+   pH263Cap->slowSqcifMPI = FALSE;
+   pH263Cap->slowQcifMPI = FALSE;
+   pH263Cap->slowCifMPI = FALSE;
+   pH263Cap->slowCif4MPI = FALSE;
+   pH263Cap->slowCif16MPI = FALSE;
+   pH263Cap->errorCompensation = FALSE;
+   return pVideo;
+}
+
+struct H245AudioCapability* ooCapabilityCreateGSMFullRateCapability
+   (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir)
+{
+   H245AudioCapability *pAudio=NULL;
+   H245GSMAudioCapability *pGSMCap=NULL;
+   if(!epCap || !epCap->params)
+   {
+     OOTRACEERR1("Error:Invalid capability parameters to "
+                 "ooCapabilityCreateGSMFullRateCapability.\n");
+     return NULL;
+   }
+
+   pAudio = (H245AudioCapability*)memAlloc(pctxt, 
+                                                sizeof(H245AudioCapability));
+   pGSMCap = (H245GSMAudioCapability*)memAlloc(pctxt, 
+                                              sizeof(H245GSMAudioCapability));
+   if(!pAudio || !pGSMCap)
+   {
+      OOTRACEERR1("ERROR:Memory - ooCapabilityCreateGSMFullRateCapability - "
+                  "pAudio/pGSMCap\n");
+      return NULL;
+   }
+   
+   pAudio->t = T_H245AudioCapability_gsmFullRate;
+   pAudio->u.gsmFullRate = pGSMCap;
+   if(dir & OORX)
+      pGSMCap->audioUnitSize = ((OOGSMCapParams*)epCap->params)->rxframes*OO_GSMFRAMESIZE;
+   else
+      pGSMCap->audioUnitSize = ((OOGSMCapParams*)epCap->params)->txframes*OO_GSMFRAMESIZE;
+ 
+   pGSMCap->comfortNoise = ((OOGSMCapParams*)epCap->params)->comfortNoise;
+   pGSMCap->scrambled = ((OOGSMCapParams*)epCap->params)->scrambled;
+
+   return pAudio;
+}
+
+/* This is used for g711 ulaw/alaw, g728, g729, g729A, g7231*/
+struct H245AudioCapability* ooCapabilityCreateSimpleCapability
+   (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir)
+{
+   H245AudioCapability *pAudio=NULL;
+   OOCapParams *params;
+   if(!epCap || !epCap->params)
+   {
+     OOTRACEERR1("Error:Invalid capability parameters to "
+                 "ooCapabilityCreateSimpleCapability.\n");
+     return NULL;
+   }
+   params =(OOCapParams*)epCap->params;
+   pAudio = (H245AudioCapability*)memAlloc(pctxt, 
+                                                sizeof(H245AudioCapability));
+   if(!pAudio)
+   {
+      OOTRACEERR1("ERROR:Memory - ooCapabilityCreateSimpleCapability - pAudio\n");
+      return NULL;
+   }
+
+   
+   switch(epCap->cap)
+   {
+   case OO_G711ALAW64K:
+      pAudio->t = T_H245AudioCapability_g711Alaw64k;
+      if(dir & OORX)
+         pAudio->u.g711Alaw64k = params->rxframes;
+      else
+         pAudio->u.g711Alaw64k = params->txframes;
+      return pAudio;
+   case OO_G711ALAW56K:
+      pAudio->t = T_H245AudioCapability_g711Alaw56k;
+      if(dir & OORX)
+         pAudio->u.g711Alaw56k = params->rxframes;
+      else
+         pAudio->u.g711Alaw56k = params->txframes; 
+      return pAudio;
+   case OO_G711ULAW64K:
+      pAudio->t = T_H245AudioCapability_g711Ulaw64k;
+      if(dir & OORX)
+         pAudio->u.g711Ulaw64k = params->rxframes;
+      else
+         pAudio->u.g711Ulaw64k = params->txframes;
+      return pAudio;
+   case OO_G711ULAW56K:
+      pAudio->t = T_H245AudioCapability_g711Ulaw56k;
+      if(dir & OORX)
+         pAudio->u.g711Ulaw56k = params->rxframes;
+      else
+         pAudio->u.g711Ulaw64k = params->txframes;
+      return pAudio;
+   /*case OO_G726:
+      pAudio->t = T_H245AudioCapability_g726;
+      if(dir & OORX)
+         pAudio->u.g726 = params->rxframes;
+      else
+         pAudio->u.g726 = params->txframes;
+      return pAudio;*/
+   case OO_G728:
+      pAudio->t = T_H245AudioCapability_g728;
+      if(dir & OORX)
+         pAudio->u.g728 = params->rxframes;
+      else
+         pAudio->u.g728 = params->txframes;
+      return pAudio;
+   case OO_G729:
+      pAudio->t = T_H245AudioCapability_g729;
+      if(dir & OORX)
+         pAudio->u.g729 = params->rxframes;
+      else
+         pAudio->u.g729 = params->txframes;
+      return pAudio;
+   case OO_G729A:
+      pAudio->t = T_H245AudioCapability_g729AnnexA;
+      if(dir & OORX)
+         pAudio->u.g729AnnexA = params->rxframes;
+      else
+         pAudio->u.g729AnnexA = params->txframes;
+      return pAudio;
+   case OO_G7231:
+      pAudio->t = T_H245AudioCapability_g7231;
+      pAudio->u.g7231 = (H245AudioCapability_g7231*)memAlloc(pctxt, 
+                                           sizeof(H245AudioCapability_g7231));
+      if(!pAudio->u.g7231)
+      {
+         OOTRACEERR1("Error:Memory - ooCapabilityCreateSimpleCapability - g7231\n");
+         memFreePtr(pctxt, pAudio);
+         return NULL;
+      }
+      pAudio->u.g7231->silenceSuppression = params->silenceSuppression;
+      if(dir & OORX)
+         pAudio->u.g7231->maxAl_sduAudioFrames = params->rxframes;
+      else
+         pAudio->u.g7231->maxAl_sduAudioFrames = params->txframes;
+      return pAudio;
+
+   default:
+      OOTRACEERR2("ERROR: Don't know how to create audio capability %d\n",
+                   epCap->cap);
+   }
+   return NULL;
+}
+
+/* Used for g711 ulaw/alaw, g728, g729, g729a, g7231 */
+ASN1BOOL ooCapabilityCheckCompatibility_Simple
+   (OOH323CallData *call, ooH323EpCapability* epCap, 
+    H245AudioCapability* audioCap, int dir)
+{
+   int noofframes=0, cap;
+
+   OOTRACEDBGC2("Comparing channel with codec type: %d\n", audioCap->t);
+
+   switch(audioCap->t)
+   {
+   case T_H245AudioCapability_g711Ulaw56k:
+      cap = OO_G711ULAW56K;
+      noofframes = audioCap->u.g711Ulaw56k;
+      break;
+   case T_H245AudioCapability_g711Ulaw64k:
+      cap = OO_G711ULAW64K;
+      noofframes = audioCap->u.g711Ulaw64k;
+      break;
+   case T_H245AudioCapability_g711Alaw64k:
+      cap = OO_G711ALAW64K;
+      noofframes = audioCap->u.g711Alaw64k;
+      break;
+   case T_H245AudioCapability_g711Alaw56k:
+      cap = OO_G711ALAW56K;
+      noofframes = audioCap->u.g711Alaw56k;
+      break;
+   /*case T_H245AudioCapability_g726:
+      cap = OO_G726;
+      noofframes = audioCap->u.g726;
+      break;*/
+   case T_H245AudioCapability_g728:
+      cap = OO_G728;
+      noofframes = audioCap->u.g728;
+      break;
+   case T_H245AudioCapability_g729:
+      cap = OO_G729;
+      noofframes = audioCap->u.g729;
+      break;
+   case T_H245AudioCapability_g729AnnexA:
+      cap = OO_G729A;
+      noofframes = audioCap->u.g729AnnexA;
+      break;   
+   case T_H245AudioCapability_g7231:
+     cap = OO_G7231;
+     noofframes = audioCap->u.g7231->maxAl_sduAudioFrames;
+     break;
+   default:
+      return FALSE;
+   }
+
+   OOTRACEDBGC3("Comparing codecs: current=%d, requested=%d\n", 
+      epCap->cap, cap);
+   if(cap != epCap->cap) { return FALSE; }
+
+   /* Can we receive this capability */
+   if(dir & OORX)
+   {
+      OOTRACEDBGC3("Comparing RX frame rate: channel's=%d, requested=%d\n",
+         ((OOCapParams*)epCap->params)->rxframes, noofframes);
+      if(((OOCapParams*)epCap->params)->rxframes >= noofframes) {
+         return TRUE;
+      }
+      //else {
+      //  not supported, as already told other ep our max. receive rate
+      //  our ep can't receive more rate than it
+      //  return FALSE;
+      //}
+   }
+
+   /* Can we transmit compatible stream */
+   if(dir & OOTX)
+   {
+      OOTRACEDBGC3("Comparing TX frame rate: channel's=%d, requested=%d\n",
+         ((OOCapParams*)epCap->params)->txframes, noofframes);
+      if(((OOCapParams*)epCap->params)->txframes <= noofframes) {
+         return TRUE;
+      }
+      //else {
+      //   TODO: reduce our ep transmission rate, as peer EP has low receive
+      //   cap, than return TRUE
+      //}
+   }
+   return FALSE;
+
+}
+
+
+OOBOOL ooCapabilityCheckCompatibility_GSM
+   (OOH323CallData *call, ooH323EpCapability* epCap, 
+    H245AudioCapability* audioCap, int dir)
+{
+   unsigned noofframes=0, cap;
+   switch(audioCap->t)
+   {
+   case T_H245AudioCapability_gsmFullRate:
+      cap = OO_GSMFULLRATE;
+      noofframes = (audioCap->u.gsmFullRate->audioUnitSize)/OO_GSMFRAMESIZE;
+      break;
+   case T_H245AudioCapability_gsmHalfRate:
+      cap = OO_GSMHALFRATE;
+      noofframes = (audioCap->u.gsmHalfRate->audioUnitSize)/OO_GSMFRAMESIZE;
+      break;
+   case T_H245AudioCapability_gsmEnhancedFullRate:
+      cap = OO_GSMENHANCEDFULLRATE;
+      noofframes = (audioCap->u.gsmEnhancedFullRate->audioUnitSize)/OO_GSMFRAMESIZE;
+      break;
+   default:
+      return FALSE;
+   }
+
+   /* can we receive this capability */
+   if(dir & OORX)
+   {
+      if(((OOGSMCapParams*)epCap->params)->rxframes >= noofframes)
+         return TRUE;
+   }
+
+   /* Make sure we transmit compatible stream */
+   if(dir & OOTX)
+   {
+      if(((OOGSMCapParams*)epCap->params)->txframes > noofframes){
+         OOTRACEDBGA5("Reducing txframes for GSM from %d to %d to match "
+                      "receive capability of remote end.(%s, %s)\n", 
+                     ((OOGSMCapParams*)epCap->params)->txframes, noofframes, 
+                     call->callType, call->callToken);
+         ((OOGSMCapParams*)epCap->params)->txframes = noofframes;
+      }
+      return TRUE;
+   }
+   return FALSE;
+
+}
+
+
+OOBOOL ooCapabilityCheckCompatibility_H263Video
+   (struct OOH323CallData *call, ooH323EpCapability *epCap, 
+    H245VideoCapability *pVideoCap, int dir)
+{
+   H245H263VideoCapability *pH263Cap = NULL;
+
+   OOH263CapParams *params = epCap->params;
+   if(!pVideoCap->u.h263VideoCapability)  
+   {
+      OOTRACEERR3("Error:No H263 video capability present in video capability"
+                 "structure. (%s, %s)\n", call->callType, call->callToken);
+      return FALSE;
+   }
+   pH263Cap = pVideoCap->u.h263VideoCapability;
+   
+   /* can we receive/transmit this capability */
+   if(OORX & dir)
+   {
+      if(pH263Cap->m.sqcifMPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_SQCIF)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->sqcifMPI >= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+      if(pH263Cap->m.qcifMPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_QCIF)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->qcifMPI >= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+      if(pH263Cap->m.cifMPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_CIF)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->cifMPI >= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+      if(pH263Cap->m.cif4MPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_CIF4)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->cif4MPI >= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+      if(pH263Cap->m.cif16MPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_CIF16)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->cif16MPI >= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+   }
+
+   /* Can we transmit */
+   if(OOTX & dir)
+   {
+       if(pH263Cap->m.sqcifMPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_SQCIF)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->sqcifMPI <= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+      if(pH263Cap->m.qcifMPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_QCIF)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->qcifMPI <= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+      if(pH263Cap->m.cifMPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_CIF)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->cifMPI <= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+      if(pH263Cap->m.cif4MPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_CIF4)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->cif4MPI <= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+      if(pH263Cap->m.cif16MPIPresent)
+      {
+         if(params->picFormat != OO_PICFORMAT_CIF16)
+         {
+            return FALSE;
+         }
+         else{
+            if(pH263Cap->cif16MPI <= params->MPI)
+               return TRUE;
+            else
+               return FALSE;
+         }
+      }
+   }
+   
+   return FALSE;
+
+}
+
+
+OOBOOL ooCapabilityCheckCompatibility_Audio
+   (OOH323CallData *call, ooH323EpCapability* epCap, 
+    H245AudioCapability* audioCap, int dir)
+{
+
+   switch(audioCap->t)
+   {
+   case T_H245AudioCapability_g711Ulaw56k:
+   case T_H245AudioCapability_g711Ulaw64k:
+   case T_H245AudioCapability_g711Alaw64k:
+   case T_H245AudioCapability_g711Alaw56k:
+   /*case T_H245AudioCapability_g726:*/
+   case T_H245AudioCapability_g728:
+   case T_H245AudioCapability_g729:
+   case T_H245AudioCapability_g729AnnexA:
+   case T_H245AudioCapability_g7231:
+      return ooCapabilityCheckCompatibility_Simple(call, epCap, audioCap, dir);
+   case T_H245AudioCapability_gsmFullRate:
+      return ooCapabilityCheckCompatibility_GSM(call, epCap, audioCap, dir);
+   default:
+      return FALSE;
+   }
+
+   return FALSE;  
+}
+
+OOBOOL ooCapabilityCheckCompatibility_Video
+   (OOH323CallData *call, ooH323EpCapability* epCap, 
+    H245VideoCapability* videoCap, int dir)
+{
+   switch(videoCap->t)
+   {
+   case T_H245VideoCapability_h263VideoCapability:
+      return ooCapabilityCheckCompatibility_H263Video(call, epCap, 
+                                                              videoCap, dir);
+   default:
+     OOTRACEDBGC3("ooCapabilityCheckCompatibility_Video - Unsupported video "
+                  "capability. (%s, %s)\n", call->callType, call->callToken);
+   }
+   return FALSE;
+}
+/*
+   Note: In faststart if we sent transmit rate (x>y) and remote
+         can receive only y, then we can't reduce our transmit rate
+*/
+OOBOOL ooCapabilityCheckCompatibility
+   (struct OOH323CallData *call, ooH323EpCapability* epCap, 
+    H245DataType* dataType, int dir)
+{
+   switch(dataType->t)
+   {
+   case T_H245DataType_audioData:
+      if(epCap->capType == OO_CAP_TYPE_AUDIO)
+         return ooCapabilityCheckCompatibility_Audio(call, epCap, 
+                                                   dataType->u.audioData, dir);
+      break;
+   case T_H245DataType_videoData:
+      if(epCap->capType == OO_CAP_TYPE_VIDEO)
+         return ooCapabilityCheckCompatibility_Video(call, epCap, 
+                                                   dataType->u.videoData, dir);
+      break;
+   case T_H245DataType_data:
+   default:
+      OOTRACEDBGC3("ooCapabilityCheckCompatibility - Unsupported  "
+                  "capability. (%s, %s)\n", call->callType, call->callToken);
+   }
+
+   return FALSE;
+}
+
+#if 0
+/**
+  TODO: If txCap is local and number of txframes is greater than remote can
+  receive, we should automatically decrease it. And logical channel cap should
+  be the one where it should be decreased. The start logical channel will
+  indicate the application that it is supposed to tx and a reduced rate.
+ */
+ASN1BOOL ooCheckCompatibility
+   (OOH323CallData *call, ooH323EpCapability *txCap, ooH323EpCapability *rxCap)
+{
+
+   if(txCap->cap != rxCap->cap) return FALSE;
+
+   if(!(txCap->dir & OOTX)) return FALSE;
+   
+   if(!(rxCap->dir & OORX)) return FALSE;
+
+   switch(txCap->cap)
+   {   
+   case OO_G711ALAW64K:
+   case OO_G711ALAW56K:
+   case OO_G711ULAW64K:
+   case OO_G711ULAW56K:
+   /*case OO_G726:*/
+   case OO_G728:
+   case OO_G729:
+   case OO_G729A:
+   case OO_G7231:
+     if(((OOCapParams*)txCap->params)->txframes <= 
+                                ((OOCapParams*)rxCap->params)->rxframes)
+       return TRUE;
+     else{
+       OOTRACEDBGA4("Simple caps %s are not compatible.(%s, %s)\n", 
+                    ooGetCapTypeText(txCap->cap), call->callType, 
+                    call->callToken);
+       return FALSE;
+     }
+   case OO_GSMFULLRATE:
+   case OO_GSMHALFRATE:
+   case OO_GSMENHANCEDFULLRATE:
+     if(((OOGSMCapParams*)txCap->params)->txframes <= 
+                                ((OOGSMCapParams*)rxCap->params)->rxframes)
+       return TRUE;
+     else{
+       OOTRACEDBGA3("GSM caps are not compatible. (%s, %s)\n", call->callType,
+                     call->callToken);
+       return FALSE;
+     }  
+   default:
+     OOTRACEWARN3("WARN: Unsupported capabilities being compared. (%s, %s)\n",
+                   call->callType, call->callToken);
+   }
+   return FALSE;
+
+}
+
+#endif
+
+ooH323EpCapability* ooIsAudioDataTypeGSMSupported
+   (OOH323CallData *call, H245AudioCapability* audioCap, int dir)
+{
+   unsigned framesPerPkt=0;
+   int cap=0;
+   ooH323EpCapability *cur = NULL, *epCap=NULL;
+   OOGSMCapParams *params = NULL;
+
+   switch(audioCap->t)
+   {
+   case T_H245AudioCapability_gsmFullRate:
+      framesPerPkt = (audioCap->u.gsmFullRate->audioUnitSize)/OO_GSMFRAMESIZE;
+      cap = OO_GSMFULLRATE;
+      break;
+   case T_H245AudioCapability_gsmHalfRate:
+      framesPerPkt = (audioCap->u.gsmHalfRate->audioUnitSize)/OO_GSMFRAMESIZE;
+      cap = OO_GSMHALFRATE;
+      break;
+   case T_H245AudioCapability_gsmEnhancedFullRate:
+      framesPerPkt = (audioCap->u.gsmEnhancedFullRate->audioUnitSize)/OO_GSMFRAMESIZE;
+      cap = OO_GSMENHANCEDFULLRATE;
+      break;
+   default:
+      OOTRACEERR3("Error:Invalid GSM capability type.(%s, %s)\n", 
+                                           call->callType, call->callToken);
+     return NULL;
+   }
+
+   OOTRACEDBGC4("Determined audio data type to be of type %d. Searching"
+                " for matching capability.(%s, %s)\n", cap, call->callType, 
+                call->callToken);
+
+   /* If we have call specific caps then we use them, otherwise we use
+      general endpoint caps*/
+   if(call->ourCaps)   
+      cur = call->ourCaps;
+   else
+      cur = gH323ep.myCaps;
+
+   while(cur)
+   {
+      OOTRACEDBGC4("Local cap being compared %d. (%s, %s)\n", cur->cap,
+                     call->callType, call->callToken);
+      
+      if(cur->cap == cap && (cur->dir & dir))
+         break;
+      cur = cur->next;
+   }
+   
+   if(!cur) return NULL;
+   
+   OOTRACEDBGC4("Found matching audio capability type %d. Comparing"
+                " other parameters. (%s, %s)\n", cap, call->callType, 
+                call->callToken);
+   
+   /* can we receive this capability */
+   if(dir & OORX)
+   {
+      if(((OOGSMCapParams*)cur->params)->rxframes < framesPerPkt)
+         return NULL;
+      else{
+         epCap = (ooH323EpCapability*)memAlloc(call->pctxt, 
+                                                 sizeof(ooH323EpCapability));
+         params =(OOGSMCapParams*)memAlloc(call->pctxt,sizeof(OOGSMCapParams));
+         if(!epCap || !params)
+         {
+            OOTRACEERR3("Error:Memory - ooIsAudioDataTypeGSMSupported - "
+                        "epCap/params (%s, %s)\n", call->callType, 
+                        call->callToken);
+            return NULL;
+         }
+         epCap->params = params;
+         epCap->cap = cur->cap;
+         epCap->dir = cur->dir;
+         epCap->capType = cur->capType;
+         epCap->startReceiveChannel = cur->startReceiveChannel;
+         epCap->startTransmitChannel= cur->startTransmitChannel;
+         epCap->stopReceiveChannel = cur->stopReceiveChannel;
+         epCap->stopTransmitChannel = cur->stopTransmitChannel;
+         epCap->next = NULL;
+         memcpy(epCap->params, cur->params, sizeof(OOGSMCapParams));
+         return epCap;
+      }
+   }
+
+   /* Can we transmit compatible stream */
+   if(dir & OOTX)
+   {
+      epCap = (ooH323EpCapability*)memAlloc(call->pctxt, 
+                                                sizeof(ooH323EpCapability));
+      params =(OOGSMCapParams*)memAlloc(call->pctxt,sizeof(OOGSMCapParams));
+      if(!epCap || !params)
+      {
+         OOTRACEERR3("Error:Memory - ooIsAudioDataTypeGSMSupported - "
+                     "epCap/params (%s, %s)\n", call->callType, 
+                     call->callToken);
+         return NULL;
+      }
+      epCap->params = params;
+      epCap->cap = cur->cap;
+      epCap->dir = cur->dir;
+      epCap->capType = cur->capType;
+      epCap->startReceiveChannel = cur->startReceiveChannel;
+      epCap->startTransmitChannel= cur->startTransmitChannel;
+      epCap->stopReceiveChannel = cur->stopReceiveChannel;
+      epCap->stopTransmitChannel = cur->stopTransmitChannel;
+      epCap->next = NULL;
+      memcpy(epCap->params, cur->params, sizeof(OOGSMCapParams));
+      if(params->txframes > framesPerPkt)
+      {
+         OOTRACEINFO5("Reducing framesPerPkt for transmission of GSM "
+                      "capability from %d to %d to match receive capability of"
+                      " remote endpoint.(%s, %s)\n", params->txframes, 
+                      framesPerPkt, call->callType, call->callToken);
+         params->txframes = framesPerPkt;
+      }
+
+      return epCap;
+
+   }
+   return NULL;
+
+}
+
+/* used for g711 ulaw/alaw, g728, g729, g729a, g7231 */
+ooH323EpCapability* ooIsAudioDataTypeSimpleSupported
+   (OOH323CallData *call, H245AudioCapability* audioCap, int dir)
+{
+   int cap, framesPerPkt=0;
+   ooH323EpCapability *cur=NULL, *epCap=NULL;
+   OOCapParams * params= NULL;
+
+   /* Find similar capability */
+   switch(audioCap->t)
+   {
+      case T_H245AudioCapability_g711Alaw64k:
+         framesPerPkt = audioCap->u.g711Alaw64k;
+         cap = OO_G711ALAW64K;
+         break;
+      case T_H245AudioCapability_g711Alaw56k:
+         framesPerPkt = audioCap->u.g711Alaw56k;
+         cap = OO_G711ALAW56K;
+         break;
+      case T_H245AudioCapability_g711Ulaw56k:
+         framesPerPkt = audioCap->u.g711Ulaw56k;
+         cap = OO_G711ULAW56K;
+         break;
+      case T_H245AudioCapability_g711Ulaw64k:
+         framesPerPkt = audioCap->u.g711Ulaw64k;
+         cap = OO_G711ULAW64K;
+         break;
+
+/*      case T_H245AudioCapability_g726:
+         framesPerPkt = audioCap->u.g726;
+         cap = OO_G726;
+         break;
+*/
+      case T_H245AudioCapability_g728:
+         framesPerPkt = audioCap->u.g728;
+         cap = OO_G728;
+         break;
+
+      case T_H245AudioCapability_g729:
+         framesPerPkt = audioCap->u.g729;
+         cap = OO_G729;
+         break;
+      case T_H245AudioCapability_g729AnnexA:
+         framesPerPkt = audioCap->u.g729AnnexA;
+         cap = OO_G729A;
+         break;
+      case T_H245AudioCapability_g7231:
+         framesPerPkt = audioCap->u.g7231->maxAl_sduAudioFrames;
+         cap = OO_G7231;
+         break;
+      default:
+         return NULL;
+   }
+
+   OOTRACEDBGC4("Determined Simple audio data type to be of type %s. Searching"
+                " for matching capability.(%s, %s)\n", 
+                ooGetCapTypeText(cap), call->callType, call->callToken);
+
+   /* If we have call specific caps, we use them; otherwise use general
+      endpoint caps
+   */   
+   if(call->ourCaps)
+     cur = call->ourCaps;
+   else
+     cur = gH323ep.myCaps;
+
+   while(cur)
+   {
+      OOTRACEDBGC4("Local cap being compared %s. (%s, %s)\n", 
+         ooGetCapTypeText(cur->cap),call->callType, call->callToken);
+      
+      if(cur->cap == cap && (cur->dir & dir))
+         break;
+      cur = cur->next;
+   }
+   
+   if(!cur) return NULL;
+   
+   OOTRACEDBGC4("Found matching simple audio capability type %s. Comparing"
+                " other parameters. (%s, %s)\n", ooGetCapTypeText(cap), 
+                call->callType, call->callToken);
+   
+   /* can we receive this capability */
+   if(dir & OORX)
+   {
+     if(((OOCapParams*)cur->params)->rxframes < framesPerPkt)
+         return NULL;
+     else{
+        OOTRACEDBGC4("We can receive Simple capability %s. (%s, %s)\n", 
+                      ooGetCapTypeText(cur->cap), call->callType, 
+                      call->callToken);
+        epCap = (ooH323EpCapability*)memAlloc(call->pctxt, 
+                                                 sizeof(ooH323EpCapability));
+        params=(OOCapParams*)memAlloc(call->pctxt,sizeof(OOCapParams));
+        if(!epCap || !params)
+        {
+           OOTRACEERR3("Error:Memory - ooIsAudioDataTypeSimpleSupported - "
+                       "epCap/params (%s, %s)\n", call->callType, 
+                       call->callToken);
+           return NULL;
+        }
+        epCap->params = params;
+        epCap->cap = cur->cap;
+        epCap->dir = cur->dir;
+        epCap->capType = cur->capType;
+        epCap->startReceiveChannel = cur->startReceiveChannel;
+        epCap->startTransmitChannel= cur->startTransmitChannel;
+        epCap->stopReceiveChannel = cur->stopReceiveChannel;
+        epCap->stopTransmitChannel = cur->stopTransmitChannel;
+        epCap->next = NULL;
+        memcpy(epCap->params, cur->params, sizeof(OOCapParams));
+        OOTRACEDBGC4("Returning copy of matched receive capability %s. "
+                     "(%s, %s)\n", 
+                     ooGetCapTypeText(cur->cap), call->callType, 
+                     call->callToken);
+        return epCap;
+     }
+   }
+
+   /* Can we transmit compatible stream */
+   if(dir & OOTX)
+   {
+      OOTRACEDBGC4("We can transmit Simple capability %s. (%s, %s)\n", 
+                   ooGetCapTypeText(cur->cap), call->callType, 
+                   call->callToken);
+      epCap = (ooH323EpCapability*)memAlloc(call->pctxt, 
+                                                sizeof(ooH323EpCapability));
+      params =(OOCapParams*)memAlloc(call->pctxt,sizeof(OOCapParams));
+      if(!epCap || !params)
+      {
+         OOTRACEERR3("Error:Memory - ooIsAudioDataTypeSimpleSupported - "
+                     "epCap/params (%s, %s)\n", call->callType, 
+                     call->callToken);
+         return NULL;
+      }
+      epCap->params = params;
+      epCap->cap = cur->cap;
+      epCap->dir = cur->dir;
+      epCap->capType = cur->capType;
+      epCap->startReceiveChannel = cur->startReceiveChannel;
+      epCap->startTransmitChannel= cur->startTransmitChannel;
+      epCap->stopReceiveChannel = cur->stopReceiveChannel;
+      epCap->stopTransmitChannel = cur->stopTransmitChannel;
+      epCap->next = NULL;
+      memcpy(epCap->params, cur->params, sizeof(OOCapParams));
+      if(params->txframes > framesPerPkt)
+      {
+         OOTRACEINFO5("Reducing framesPerPkt for transmission of Simple "
+                      "capability from %d to %d to match receive capability of"
+                      " remote endpoint.(%s, %s)\n", params->txframes, 
+                      framesPerPkt, call->callType, call->callToken);
+         params->txframes = framesPerPkt;
+      }
+      OOTRACEDBGC4("Returning copy of matched transmit capability %s."
+                   "(%s, %s)\n", 
+                   ooGetCapTypeText(cur->cap), call->callType, 
+                   call->callToken);
+      return epCap;
+   }
+   return NULL;
+}
+
+
+
+ooH323EpCapability* ooIsAudioDataTypeSupported
+   (OOH323CallData *call, H245AudioCapability* audioCap, int dir)
+{
+   /* Find similar capability */
+   switch(audioCap->t)
+   {
+      case T_H245AudioCapability_g711Alaw64k:
+      case T_H245AudioCapability_g711Alaw56k:
+      case T_H245AudioCapability_g711Ulaw56k:
+      case T_H245AudioCapability_g711Ulaw64k:
+      /*case T_H245AudioCapability_g726:*/
+      case T_H245AudioCapability_g728:
+      case T_H245AudioCapability_g729:
+      case T_H245AudioCapability_g729AnnexA:
+      case T_H245AudioCapability_g7231:
+         return ooIsAudioDataTypeSimpleSupported(call, audioCap, dir);
+      case T_H245AudioCapability_gsmFullRate:
+      case T_H245AudioCapability_gsmHalfRate:
+      case T_H245AudioCapability_gsmEnhancedFullRate:
+         return ooIsAudioDataTypeGSMSupported(call, audioCap, dir);   
+      default:
+         return NULL;
+   }   
+}
+
+
+ooH323EpCapability* ooIsVideoDataTypeH263Supported
+   (OOH323CallData *call, H245H263VideoCapability* pH263Cap, int dir, 
+    OOPictureFormat picFormat)
+{
+   int cap;
+   ooH323EpCapability *cur=NULL, *epCap=NULL;
+   OOH263CapParams *params= NULL;   
+   char *pictureType=NULL;
+   unsigned mpi=0;
+   cap = OO_H263VIDEO;
+
+   if(picFormat == OO_PICFORMAT_SQCIF && pH263Cap->m.sqcifMPIPresent)
+   {
+      pictureType = "SQCIF";
+      mpi = pH263Cap->sqcifMPI;
+   }
+   if(picFormat == OO_PICFORMAT_QCIF && pH263Cap->m.qcifMPIPresent)
+   {
+      pictureType = "QCIF";
+      mpi = pH263Cap->qcifMPI;
+   }
+   if(picFormat == OO_PICFORMAT_CIF && pH263Cap->m.cifMPIPresent)
+   {
+      pictureType = "CIF";
+      mpi = pH263Cap->cifMPI;
+   }
+   if(picFormat == OO_PICFORMAT_CIF4 && pH263Cap->m.cif4MPIPresent)
+   {
+      pictureType = "CIF4";
+      mpi = pH263Cap->cif4MPI;
+   }
+   if(picFormat == OO_PICFORMAT_CIF16 && pH263Cap->m.cif16MPIPresent)
+   {
+      pictureType = "CIF16";
+      mpi = pH263Cap->cif16MPI;
+   }
+   
+
+   OOTRACEDBGA4("Looking for H263 video capability(%s). (%s, %s)\n", 
+                 pictureType, call->callType, call->callToken);
+
+  /* If we have call specific caps, we use them; otherwise use general
+      endpoint caps
+   */   
+   if(call->ourCaps)
+     cur = call->ourCaps;
+   else
+     cur = gH323ep.myCaps;
+
+   while(cur)
+   {
+      OOTRACEDBGC4("Local cap being compared %s. (%s, %s)\n", 
+              ooGetCapTypeText(cur->cap),call->callType, call->callToken);
+      
+      if(cur->cap == cap && (cur->dir & dir))
+      {
+         if(((OOH263CapParams*)cur->params)->picFormat == picFormat)
+            break;
+      }
+      cur = cur->next;
+   }
+   
+   if(!cur) return NULL;
+   
+   OOTRACEDBGC4("Found matching H.263 video capability type %s. Comparing"
+                " other parameters. (%s, %s)\n", ooGetCapTypeText(cap), 
+                call->callType, call->callToken);   
+   if(dir & OORX)
+   {
+      if(mpi < ((OOH263CapParams*)cur->params)->MPI)
+         return NULL;
+      else{
+         epCap = (ooH323EpCapability*)memAlloc(call->pctxt, 
+                                                   sizeof(ooH323EpCapability));
+         params = (OOH263CapParams*) memAlloc(call->pctxt, 
+                                                      sizeof(OOH263CapParams));
+         if(!epCap || !params)
+         {
+            OOTRACEERR3("Error:Memory - ooIsVideoDataTypeH263Supported - "
+                       "epCap/params. (%s, %s)\n", call->callType, 
+                        call->callToken);
+            return NULL;
+         }
+         epCap->params = params;
+         epCap->cap = cur->cap;
+         epCap->dir = cur->dir;
+         epCap->capType = cur->capType;
+         epCap->startReceiveChannel = cur->startReceiveChannel;
+         epCap->startTransmitChannel= cur->startTransmitChannel;
+         epCap->stopReceiveChannel = cur->stopReceiveChannel;
+         epCap->stopTransmitChannel = cur->stopTransmitChannel;
+         epCap->next = NULL;
+         memcpy(epCap->params, cur->params, sizeof(OOH263CapParams));
+         OOTRACEDBGC4("Returning copy of matched receive capability %s. "
+                     "(%s, %s)\n", ooGetCapTypeText(cur->cap), call->callType, 
+                     call->callToken);
+         return epCap;
+      }
+   }
+   if(dir & OOTX)
+   {
+      epCap = (ooH323EpCapability*)memAlloc(call->pctxt, 
+                                                  sizeof(ooH323EpCapability));
+      params = (OOH263CapParams*) memAlloc(call->pctxt, 
+                                                      sizeof(OOH263CapParams));
+      if(!epCap || !params)
+      {
+         OOTRACEERR3("Error:Memory - ooIsVideoDataTypeH263Supported - "
+                     "epCap/params. (%s, %s)\n", call->callType, 
+                     call->callToken);
+         return NULL;
+      }
+      epCap->params = params;
+      epCap->cap = cur->cap;
+      epCap->dir = cur->dir;
+      epCap->capType = cur->capType;
+      epCap->startReceiveChannel = cur->startReceiveChannel;
+      epCap->startTransmitChannel= cur->startTransmitChannel;
+      epCap->stopReceiveChannel = cur->stopReceiveChannel;
+      epCap->stopTransmitChannel = cur->stopTransmitChannel;
+      epCap->next = NULL;
+      memcpy(epCap->params, cur->params, sizeof(OOH263CapParams));
+      if(params->MPI < mpi)
+      {
+         OOTRACEINFO5("Increasing minimum picture interval for transmission of"
+                      " H263 video capability from %d to %d to match receive "
+                      "capability of remote endpoint.(%s, %s)\n", params->MPI, 
+                      mpi, call->callType, call->callToken);
+         params->MPI = mpi;
+      }
+      OOTRACEDBGC4("Returning copy of matched receive capability %s. "
+                  "(%s, %s)\n", ooGetCapTypeText(cur->cap), call->callType, 
+                  call->callToken);
+      return epCap;
+   }
+   return NULL;
+
+}
+
+ooH323EpCapability* ooIsVideoDataTypeSupported
+   (OOH323CallData *call, H245VideoCapability* pVideoCap, int dir)
+{
+   switch(pVideoCap->t)   
+   {
+   case T_H245VideoCapability_h263VideoCapability:
+      if(pVideoCap->u.h263VideoCapability->m.sqcifMPIPresent)
+         return ooIsVideoDataTypeH263Supported(call, 
+                    pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_SQCIF);
+      else if(pVideoCap->u.h263VideoCapability->m.qcifMPIPresent)
+         return ooIsVideoDataTypeH263Supported(call, 
+                     pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_QCIF);
+      else if(pVideoCap->u.h263VideoCapability->m.cifMPIPresent)
+        return ooIsVideoDataTypeH263Supported(call, 
+                      pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF);
+      else if(pVideoCap->u.h263VideoCapability->m.cif4MPIPresent)
+        return ooIsVideoDataTypeH263Supported(call, 
+                     pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF4);
+      else if(pVideoCap->u.h263VideoCapability->m.cif16MPIPresent)
+        return ooIsVideoDataTypeH263Supported(call, 
+                    pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF16);
+      break;  
+   case T_H245VideoCapability_nonStandard:
+   case T_H245VideoCapability_h261VideoCapability:
+   case T_H245VideoCapability_h262VideoCapability:
+   case T_H245VideoCapability_is11172VideoCapability:
+   case T_H245VideoCapability_genericVideoCapability:
+   case T_H245VideoCapability_extElem1:
+   default:
+     OOTRACEDBGA1("Unsupported video capability type in "
+                  "ooIsVideoDataTypeSupported\n");
+      return NULL;
+   }
+   return NULL;
+}
+
+ooH323EpCapability* ooIsDataTypeSupported
+                   (OOH323CallData *call, H245DataType *data, int dir)
+{
+   OOTRACEDBGC3("Looking for data type support. (%s, %s)\n", call->callType, 
+                 call->callToken);
+    
+   switch(data->t)
+   {
+   case T_H245DataType_nonStandard:
+      OOTRACEDBGC3("NonStandard data type not supported.(%s, %s)\n", 
+                   call->callType, call->callToken);
+      return NULL;
+   case T_H245DataType_nullData:
+      OOTRACEDBGC3("Null data type not supported.(%s, %s)\n", 
+                   call->callType, call->callToken);
+      return NULL;
+   case T_H245DataType_videoData:
+      OOTRACEDBGC3("Looking for video dataType support. (%s, %s)\n",
+                    call->callType, call->callToken);
+      return ooIsVideoDataTypeSupported(call, data->u.videoData, dir);
+   case T_H245DataType_audioData:
+      OOTRACEDBGC3("Looking for audio dataType support. (%s, %s)\n",
+                    call->callType, call->callToken);
+      return ooIsAudioDataTypeSupported(call, data->u.audioData, dir);
+   case T_H245DataType_data:
+     OOTRACEDBGC3("Data type not supported.(%s, %s)\n", 
+                   call->callType, call->callToken);
+     return NULL;
+   case T_H245DataType_encryptionData:
+     OOTRACEDBGC3("Encryption data type not supported.(%s, %s)\n", 
+                   call->callType, call->callToken);
+     return NULL;
+   case T_H245DataType_h235Control:
+     return NULL;
+   case T_H245DataType_h235Media:
+     return NULL;
+   case T_H245DataType_multiplexedStream:
+     return NULL;
+   default:
+      OOTRACEINFO3("Unknown data type (%s, %s)\n", call->callType, 
+                    call->callToken);
+   }
+   return NULL;
+}
+
+int ooResetCapPrefs(OOH323CallData *call)
+{
+   OOCapPrefs *capPrefs=NULL;
+   if(call)
+      capPrefs = &call->capPrefs;
+   else
+      capPrefs = &gH323ep.capPrefs;
+   memset(capPrefs, 0, sizeof(OOCapPrefs));
+   return OO_OK;
+}
+
+int ooRemoveCapFromCapPrefs(OOH323CallData *call, int cap)
+{
+   int i=0, j=0;
+   OOCapPrefs *capPrefs=NULL, oldPrefs;
+   if(call)
+      capPrefs = &call->capPrefs;
+   else
+      capPrefs = &gH323ep.capPrefs;
+
+   memcpy(&oldPrefs, capPrefs, sizeof(OOCapPrefs));
+   memset(capPrefs, 0, sizeof(OOCapPrefs));
+   for(i=0; i<oldPrefs.index; i++)
+   {  
+      if(oldPrefs.order[i] != cap) 
+         capPrefs->order[j++] = oldPrefs.order[i];
+   }
+   capPrefs->index = j;
+   return OO_OK;
+}
+
+ 
+int ooAppendCapToCapPrefs(OOH323CallData *call, int cap)
+{
+   OOCapPrefs *capPrefs=NULL;
+   if(call)
+      capPrefs = &call->capPrefs;
+   else
+      capPrefs = &gH323ep.capPrefs;
+
+   capPrefs->order[capPrefs->index++] = cap;
+   return OO_OK;
+}
+
+int ooChangeCapPrefOrder(OOH323CallData *call, int cap, int pos)
+{
+   int i=0, j=0;
+   OOCapPrefs *capPrefs = NULL;
+
+   /* Whether to change prefs for call or for endpoint as a whole */
+   if(call)
+      capPrefs = &call->capPrefs;
+   else
+      capPrefs = &gH323ep.capPrefs;
+
+   /* check whether cap exists, cap must exist */
+   for(i=0; i<capPrefs->index; i++)
+   {
+      if(capPrefs->order[i] == cap)
+         break;
+   }
+   if(i == capPrefs->index) return OO_FAILED;
+
+   if(i==pos) return OO_OK; /* No need to change */
+
+   /* Decrease Pref order */
+   if(i < pos)
+   {
+      for( ; i<pos; i++) 
+         capPrefs->order[i] = capPrefs->order[i+1];
+      capPrefs->order[i]=cap;
+      return OO_OK;
+   }
+   /* Increase Pref order */
+   if(i>pos)
+   {
+     for(j=i; j>pos; j--)
+       capPrefs->order[j] = capPrefs->order[j-1];
+     capPrefs->order[j] = cap;
+     return OO_OK;
+   }
+
+   return OO_FAILED;
+
+}
+
+int ooPreppendCapToCapPrefs(OOH323CallData *call, int cap)
+{
+   int i=0, j=0;
+   OOCapPrefs *capPrefs=NULL, oldPrefs;
+   if(call)
+      capPrefs = &call->capPrefs;
+   else
+      capPrefs = &gH323ep.capPrefs;
+
+   memcpy(&oldPrefs, capPrefs, sizeof(OOCapPrefs));
+
+ 
+   capPrefs->order[j++] = cap;
+
+   for(i=0; i<oldPrefs.index; i++)
+   {  
+      if(oldPrefs.order[i] != cap) 
+         capPrefs->order[j++] = oldPrefs.order[i];
+   }
+   capPrefs->index = j;
+   return OO_OK;
+}
+
+       
+int ooAddRemoteCapability(OOH323CallData *call, H245Capability *cap)
+{
+   switch(cap->t)
+   {
+   case T_H245Capability_receiveAudioCapability:
+     return ooAddRemoteAudioCapability(call, cap->u.receiveAudioCapability, 
+                                       OORX);
+   case T_H245Capability_transmitAudioCapability:
+     return ooAddRemoteAudioCapability(call, cap->u.transmitAudioCapability, 
+                                       OOTX);
+   case T_H245Capability_receiveAndTransmitAudioCapability:
+     return ooAddRemoteAudioCapability(call, 
+                             cap->u.receiveAndTransmitAudioCapability, OORXTX);
+   default:
+     OOTRACEDBGA3("Unsupported cap type encountered. Ignoring. (%s, %s)\n", 
+                   call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooAddRemoteAudioCapability(OOH323CallData *call, 
+                               H245AudioCapability *audioCap,
+                               int dir)
+{
+   int rxframes=0, txframes=0;
+  
+   switch(audioCap->t)
+   {
+   case T_H245AudioCapability_g711Alaw64k:
+      if(dir&OOTX) txframes = audioCap->u.g711Alaw64k;
+      else if(dir&OORX) rxframes = audioCap->u.g711Alaw64k;
+      else{ 
+         txframes = audioCap->u.g711Alaw64k; 
+         rxframes = audioCap->u.g711Alaw64k; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G711ALAW64K, txframes, 
+                            rxframes, FALSE, dir, NULL, NULL, NULL, NULL,TRUE);
+   case T_H245AudioCapability_g711Alaw56k:
+      if(dir&OOTX) txframes = audioCap->u.g711Alaw56k;
+      else if(dir&OORX) rxframes = audioCap->u.g711Alaw56k;
+      else{ 
+         txframes = audioCap->u.g711Alaw56k; 
+         rxframes = audioCap->u.g711Alaw56k; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G711ALAW56K, txframes, 
+                           rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE);
+   case T_H245AudioCapability_g711Ulaw64k:
+      if(dir&OOTX) txframes = audioCap->u.g711Ulaw64k;
+      else if(dir&OORX) rxframes = audioCap->u.g711Ulaw64k;
+      else{ 
+         txframes = audioCap->u.g711Ulaw64k; 
+         rxframes = audioCap->u.g711Ulaw64k; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G711ULAW64K, txframes, 
+                           rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE);
+   case T_H245AudioCapability_g711Ulaw56k:
+      if(dir&OOTX) txframes = audioCap->u.g711Ulaw56k;
+      else if(dir&OORX) rxframes = audioCap->u.g711Ulaw56k;
+      else{ 
+         txframes = audioCap->u.g711Ulaw56k; 
+         rxframes = audioCap->u.g711Ulaw56k; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G711ULAW56K, txframes, 
+                           rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE);
+
+/*   case T_H245AudioCapability_g726:
+      if(dir&OOTX) txframes = audioCap->u.g726;
+      else if(dir&OORX) rxframes = audioCap->u.g726;
+      else{ 
+         txframes = audioCap->u.g726; 
+         rxframes = audioCap->u.g726; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G726, txframes, 
+                           rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE);
+*/
+   case T_H245AudioCapability_g728:
+      if(dir&OOTX) txframes = audioCap->u.g728;
+      else if(dir&OORX) rxframes = audioCap->u.g728;
+      else{ 
+         txframes = audioCap->u.g728; 
+         rxframes = audioCap->u.g728; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G728, txframes, 
+                           rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE);
+
+   case T_H245AudioCapability_g729:
+      if(dir&OOTX) txframes = audioCap->u.g729;
+      else if(dir&OORX) rxframes = audioCap->u.g729;
+      else{ 
+         txframes = audioCap->u.g729; 
+         rxframes = audioCap->u.g729; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G729, txframes, 
+                           rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE);
+
+   case T_H245AudioCapability_g729AnnexA:
+      if(dir&OOTX) txframes = audioCap->u.g729AnnexA;
+      else if(dir&OORX) rxframes = audioCap->u.g729AnnexA;
+      else{ 
+         txframes = audioCap->u.g729AnnexA; 
+         rxframes = audioCap->u.g729AnnexA; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G729A, txframes, 
+                           rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE);
+
+   case T_H245AudioCapability_g7231:
+      if(dir&OOTX) txframes = audioCap->u.g7231->maxAl_sduAudioFrames;
+      else if(dir&OORX) rxframes = audioCap->u.g7231->maxAl_sduAudioFrames;
+      else{ 
+         txframes = audioCap->u.g7231->maxAl_sduAudioFrames; 
+         rxframes = audioCap->u.g7231->maxAl_sduAudioFrames; 
+      }
+      return ooCapabilityAddSimpleCapability(call, OO_G7231, txframes,rxframes,
+                                         audioCap->u.g7231->silenceSuppression,
+                                         dir, NULL, NULL, NULL, NULL, TRUE); 
+   case T_H245AudioCapability_gsmFullRate:
+      return ooCapabilityAddGSMCapability(call, OO_GSMFULLRATE, 
+            (unsigned)(audioCap->u.gsmFullRate->audioUnitSize/OO_GSMFRAMESIZE),
+                                        audioCap->u.gsmFullRate->comfortNoise,
+                                        audioCap->u.gsmFullRate->scrambled, 
+                                        dir, NULL, NULL, NULL, NULL, TRUE);
+   case T_H245AudioCapability_gsmHalfRate:
+      return ooCapabilityAddGSMCapability(call, OO_GSMHALFRATE,
+            (unsigned)(audioCap->u.gsmHalfRate->audioUnitSize/OO_GSMFRAMESIZE),
+                                        audioCap->u.gsmHalfRate->comfortNoise,
+                                        audioCap->u.gsmHalfRate->scrambled, 
+                                        dir, NULL, NULL, NULL, NULL, TRUE);
+   case T_H245AudioCapability_gsmEnhancedFullRate:
+      return ooCapabilityAddGSMCapability(call, OO_GSMENHANCEDFULLRATE, 
+   (unsigned)(audioCap->u.gsmEnhancedFullRate->audioUnitSize/OO_GSMFRAMESIZE),
+                                audioCap->u.gsmEnhancedFullRate->comfortNoise,
+                                audioCap->u.gsmEnhancedFullRate->scrambled, 
+                                dir, NULL, NULL, NULL, NULL, TRUE);
+
+   default:
+     OOTRACEDBGA1("Unsupported audio capability type\n");
+   
+   }
+
+   return OO_OK;
+}
+
+
+
+
+
+int ooCapabilityUpdateJointCapabilities
+   (OOH323CallData* call, H245Capability *cap)
+{
+   ooH323EpCapability * epCap = NULL, *cur = NULL;
+   OOTRACEDBGC3("checking whether we need to add cap to joint capabilities"
+                "(%s, %s)\n", call->callType, call->callToken);
+            
+   switch(cap->t)
+   {
+   case T_H245Capability_receiveAudioCapability:
+      epCap= ooIsAudioDataTypeSupported(call, cap->u.receiveAudioCapability, 
+                                        OOTX);
+      break;
+   case T_H245Capability_transmitAudioCapability:
+      epCap = ooIsAudioDataTypeSupported(call, cap->u.transmitAudioCapability,
+                                        OORX);
+      break;
+   case T_H245Capability_receiveAndTransmitAudioCapability:
+      epCap = NULL;
+      break;
+   case T_H245Capability_receiveVideoCapability:
+      return ooCapabilityUpdateJointCapabilitiesVideo(call, 
+                                          cap->u.receiveVideoCapability, OOTX);
+   case T_H245Capability_transmitVideoCapability:
+      return ooCapabilityUpdateJointCapabilitiesVideo(call, 
+                                         cap->u.transmitVideoCapability, OORX);
+   case T_H245Capability_receiveUserInputCapability:
+      if((cap->u.receiveUserInputCapability->t == 
+                                 T_H245UserInputCapability_basicString) &&
+         (call->dtmfmode & OO_CAP_DTMF_H245_alphanumeric))
+      {
+         call->jointDtmfMode |= OO_CAP_DTMF_H245_alphanumeric;
+         return OO_OK;
+      }
+      else if((cap->u.receiveUserInputCapability->t ==
+               T_H245UserInputCapability_dtmf) &&
+               (call->dtmfmode & OO_CAP_DTMF_H245_signal))
+      {
+         call->jointDtmfMode |= OO_CAP_DTMF_H245_signal;
+         return OO_OK;
+      }
+      //break;
+   default:
+     OOTRACEDBGA3("Unsupported cap type encountered. Ignoring. (%s, %s)\n", 
+                   call->callType, call->callToken);
+   }
+
+   if(epCap)
+   {
+      OOTRACEDBGC3("Adding cap to joint capabilities(%s, %s)\n",call->callType,
+                   call->callToken);
+      /* Note:we add jointCaps in remote endpoints preference order.*/
+      if(!call->jointCaps)
+         call->jointCaps = epCap;
+      else {
+         cur = call->jointCaps;
+         while(cur->next) cur = cur->next;
+         cur->next = epCap;
+      }
+
+      return OO_OK;
+   }
+
+   OOTRACEDBGC3("Not adding to joint capabilities. (%s, %s)\n", call->callType,
+                call->callToken);
+   return OO_OK;
+}
+
+
+
+int ooCapabilityUpdateJointCapabilitiesVideo
+   (OOH323CallData *call, H245VideoCapability *videoCap, int dir)
+{
+   switch(videoCap->t)
+   {
+   case T_H245VideoCapability_h263VideoCapability:
+      return ooCapabilityUpdateJointCapabilitiesVideoH263(call, 
+                                        videoCap->u.h263VideoCapability, dir);
+   default:
+      OOTRACEDBGC3("ooCapabilityUpdateJointCapabilitiesVideo - Unsupported"
+                   "capability type. (%s, %s)\n", call->callType, 
+                   call->callToken);
+   }
+   return OO_OK;
+}
+
+
+int ooCapabilityUpdateJointCapabilitiesVideoH263
+   (OOH323CallData *call, H245H263VideoCapability *pH263Cap, int dir)
+{
+   ooH323EpCapability *epCap = NULL, *cur = NULL;
+   if(pH263Cap->m.sqcifMPIPresent)
+   {
+      epCap =  ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, 
+                                                          OO_PICFORMAT_SQCIF);
+      if(epCap)
+      {
+         OOTRACEDBGC3("Adding H263-SQCIF to joint capabilities(%s, %s)\n",
+                      call->callType, call->callToken);
+         /* Note:we add jointCaps in remote endpoints preference order.*/
+         if(!call->jointCaps)
+            call->jointCaps = epCap;
+         else {
+            cur = call->jointCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+
+      }     
+   }
+
+   epCap = NULL;
+
+   if(pH263Cap->m.qcifMPIPresent)
+   {
+      epCap =  ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, 
+                                                          OO_PICFORMAT_QCIF);
+      if(epCap)
+      {
+         OOTRACEDBGC3("Adding H263-QCIF to joint capabilities(%s, %s)\n",
+                      call->callType, call->callToken);
+         /* Note:we add jointCaps in remote endpoints preference order.*/
+         if(!call->jointCaps)
+            call->jointCaps = epCap;
+         else {
+            cur = call->jointCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+
+      }     
+   }
+
+   epCap = NULL;
+
+   if(pH263Cap->m.cifMPIPresent)
+   {
+      epCap =  ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, 
+                                                          OO_PICFORMAT_CIF);
+      if(epCap)
+      {
+         OOTRACEDBGC3("Adding H263-CIF to joint capabilities(%s, %s)\n",
+                      call->callType, call->callToken);
+         /* Note:we add jointCaps in remote endpoints preference order.*/
+         if(!call->jointCaps)
+            call->jointCaps = epCap;
+         else {
+            cur = call->jointCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+
+      }     
+   }
+
+   epCap = NULL;
+
+   if(pH263Cap->m.cif4MPIPresent)
+   {
+      epCap =  ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, 
+                                                          OO_PICFORMAT_CIF4);
+      if(epCap)
+      {
+         OOTRACEDBGC3("Adding H263-CIF4 to joint capabilities(%s, %s)\n",
+                      call->callType, call->callToken);
+         /* Note:we add jointCaps in remote endpoints preference order.*/
+         if(!call->jointCaps)
+            call->jointCaps = epCap;
+         else {
+            cur = call->jointCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+      }     
+   }
+
+   epCap = NULL;
+
+   if(pH263Cap->m.cif16MPIPresent)
+   {
+      epCap =  ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, 
+                                                          OO_PICFORMAT_CIF16);
+      if(epCap)
+      {
+         OOTRACEDBGC3("Adding H263-CIF16 to joint capabilities(%s, %s)\n",
+                      call->callType, call->callToken);
+         /* Note:we add jointCaps in remote endpoints preference order.*/
+         if(!call->jointCaps)
+            call->jointCaps = epCap;
+         else {
+            cur = call->jointCaps;
+            while(cur->next) cur = cur->next;
+            cur->next = epCap;
+         }
+
+      }     
+   }
+
+   return OO_OK;
+}
+
+const char* ooGetCapTypeText (OOCapabilities cap)
+{
+   static const char *capTypes[]={
+      "unknown",
+      "OO_NONSTANDARD",
+      "OO_G711ALAW64K",
+      "OO_G711ALAW56K",
+      "OO_G711ULAW64K",
+      "OO_G711ULAW56K",
+      "OO_G72264K",
+      "OO_G72256K",
+      "OO_G72248K",
+      "OO_G7231",
+      "OO_G728",
+      "OO_G729",
+      "OO_G729ANNEXA",
+      "OO_IS11172AUDIO",
+      "OO_IS13818AUDIO",
+      "OO_G729WANNEXB",
+      "OO_G729ANNEXAWANNEXB",
+      "OO_G7231ANNEXC",
+      "OO_GSMFULLRATE",
+      "OO_GSMHALFRATE",
+      "OO_GSMENHANCEDFULLRATE",
+      "OO_GENERICAUDIO",
+      "OO_G729EXTENSIONS",
+      "OO_VBD",
+      "OO_AUDIOTELEPHONYEVENT",
+      "OO_AUDIOTONE",
+      "OO_EXTELEM1",
+      "OO_VIDEO_BASE",
+      "OO_NONSTDVIDEO",
+      "OO_H261VIDEO",
+      "OO_H262VIDEO",
+      "OO_H263VIDEO",
+      "OO_IS11172VIDEO",  /* mpeg */
+      "OO_GENERICVIDEO",
+      "OO_EXTELEMVIDEO"
+   };
+   return ooUtilsGetText (cap, capTypes, OONUMBEROF(capTypes));
+}
diff --git a/addons/ooh323c/src/ooCapability.h b/addons/ooh323c/src/ooCapability.h
new file mode 100644
index 000000000..75d0d563a
--- /dev/null
+++ b/addons/ooh323c/src/ooCapability.h
@@ -0,0 +1,726 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file ooCapability.h 
+ * This file contains Capability management functions. 
+ */
+#ifndef OO_CAPABILITY_H_
+#define OO_CAPABILITY_H_
+#include "ootypes.h"
+#include "ooasn1.h"
+
+
+#define OO_GSMFRAMESIZE 33 /* standard frame size for gsm is 33 bytes */
+
+#define OORX      (1<<0)
+#define OOTX      (1<<1)
+#define OORXANDTX (1<<2)
+#define OORXTX    (1<<3) /* For symmetric capabilities */
+/* Various types of caps. Note that not all 
+   supported */
+typedef enum OOCapabilities{
+   OO_CAP_AUDIO_BASE      = 0,
+   OO_G711ALAW64K         = 2,
+   OO_G711ALAW56K         = 3,
+   OO_G711ULAW64K         = 4,
+   OO_G711ULAW56K         = 5,
+   OO_G722_64k            = 6,
+   OO_G722_56k            = 7,
+   OO_G722_48k            = 8,
+   OO_G7231               = 9,
+   OO_G728                = 10,
+   OO_G729                = 11,
+   OO_G729A               = 12,
+   OO_IS11172_AUDIO       = 13,
+   OO_IS13818_AUDIO       = 14,
+   OO_G729B               = 15,
+   OO_G729AB              = 16,
+   OO_G7231C              = 17,
+   OO_GSMFULLRATE         = 18,
+   OO_GSMHALFRATE         = 19,
+   OO_GSMENHANCEDFULLRATE = 20,
+   OO_GENERICAUDIO        = 21,
+   OO_G729EXT             = 22,
+   OO_AUDIO_VBD           = 23,
+   OO_AUDIOTELEPHONYEVENT = 24,
+   OO_AUDIO_TONE          = 25,
+   OO_EXTELEM1            = 26,
+   OO_CAP_VIDEO_BASE      = 27,
+   OO_NONSTDVIDEO         = 28,
+   OO_H261VIDEO           = 29,
+   OO_H262VIDEO           = 30,
+   OO_H263VIDEO           = 31,
+   OO_IS11172VIDEO        = 32,  /* mpeg */
+   OO_GENERICVIDEO        = 33,
+   OO_EXTELEMVIDEO        = 34
+} OOCapabilities;
+
+
+/*DTMF capabilities*/
+#define OO_CAP_DTMF_RFC2833              (1<<0)
+#define OO_CAP_DTMF_Q931                 (1<<1)
+#define OO_CAP_DTMF_H245_alphanumeric    (1<<2)
+#define OO_CAP_DTMF_H245_signal          (1<<3)
+
+/**
+ * This structure defines the preference order for capabilities.
+ * 
+ */
+typedef struct OOCapPrefs {
+  int order[20];
+  int index;
+}OOCapPrefs;
+
+typedef struct OOCapParams {
+   int txframes;  /*!< Number of frames per packet for transmission */
+   int rxframes;  /*!< Number of frames per packet for reception */
+   OOBOOL silenceSuppression; 
+} OOCapParams;
+
+typedef struct OOGSMCapParams {
+   unsigned txframes; 
+   unsigned rxframes;
+   OOBOOL scrambled;
+   OOBOOL comfortNoise;
+} OOGSMCapParams;
+
+typedef enum OOPictureFormat{
+   OO_PICFORMAT_SQCIF,
+   OO_PICFORMAT_QCIF,
+   OO_PICFORMAT_CIF,
+   OO_PICFORMAT_CIF4,
+   OO_PICFORMAT_CIF16
+}OOPictureFormat;
+
+typedef struct OOH263CapParams {
+   enum OOPictureFormat picFormat; /* !< One of sqcif, qcif, cif, cif4, cif16*/
+   unsigned MPI; /* !< Minimum Picture Interval */
+  unsigned maxBitRate; /* !< Maximum bit rate for transmission/reception in units of 100 bits/sec */
+} OOH263CapParams;
+
+struct OOH323CallData;
+struct OOLogicalChannel;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** 
+ * This callback is used for starting media receive channel. This callback
+ * function is triggered when receive media channel has to be started.
+ * @param call     Call for which receive media channel has to be started.
+ * @param pChannel Channel details. This structure has important information
+ *                 such as rtp ip:port and capability describing media type
+ *                 to be received.
+ * @return         OO_OK, on success. OO_FAILED, on failure
+ */
+typedef int (*cb_StartReceiveChannel)
+     (struct OOH323CallData *call, struct OOLogicalChannel *pChannel);
+
+
+/** 
+ * This callback is used for starting media transmit channel. This callback
+ * function is triggered when transmit media channel has to be started.
+ * @param call     Call for which transmit media channel has to be started.
+ * @param pChannel Channel details. This structure has important information
+ *                 such as rtp ip:port and capability describing media type
+ *                 to be transmitted.
+ * @return         OO_OK, on success. OO_FAILED, on failure
+ */
+typedef int (*cb_StartTransmitChannel)
+     (struct OOH323CallData *call, struct OOLogicalChannel *pChannel);
+
+/** 
+ * This callback is used for stopping media receive channel. This callback
+ * function is triggered when receive media channel has to be stopped.
+ * @param call     Call for which receive media channel has to be stopped.
+ * @param pChannel Channel details. This structure has important information
+ *                 such as rtp ip:port and capability describing media type
+ *                 being received.
+ * @return         OO_OK, on success. OO_FAILED, on failure
+ */
+typedef int (*cb_StopReceiveChannel)
+     (struct OOH323CallData *call, struct OOLogicalChannel *pChannel);
+
+/** 
+ * This callback is used for stopping media transmit channel. This callback
+ * function is triggered when transmit media channel has to be stopped.
+ * @param call     Call for which transmit media channel has to be stopped.
+ * @param pChannel Channel details. This structure has important information
+ *                 such as rtp ip:port and capability describing media type
+ *                 being transmitted.
+ * @return         OO_OK, on success. OO_FAILED, on failure
+ */
+typedef int (*cb_StopTransmitChannel)
+     (struct OOH323CallData *call, struct OOLogicalChannel *pChannel);
+
+typedef enum OOCapType {
+   OO_CAP_TYPE_AUDIO,
+   OO_CAP_TYPE_VIDEO,
+   OO_CAP_TYPE_DATA
+} OOCapType;
+
+/**
+ * Structure to store information related to end point
+ * capability
+ */
+typedef struct ooH323EpCapability {
+   int dir; 
+   int cap;
+   OOCapType capType;
+   void *params;
+   cb_StartReceiveChannel startReceiveChannel;
+   cb_StartTransmitChannel startTransmitChannel;
+   cb_StopReceiveChannel stopReceiveChannel;
+   cb_StopTransmitChannel stopTransmitChannel;
+   struct ooH323EpCapability *next;
+} ooH323EpCapability;
+
+
+
+
+#ifndef EXTERN
+#if defined (MAKE_DLL)
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+/** 
+ * @defgroup capmgmt  Capability Management
+ * @{
+ */
+
+/**
+ * This function is used to add rfc2833 based dtmf detection capability
+ * @param call                   Call if enabling for call, else null for 
+ *                               endpoint.
+ * @param dynamicRTPPayloadType  dynamicRTPPayloadType to be used.
+ * @return                       OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityEnableDTMFRFC2833
+   (struct OOH323CallData *call, int dynamicRTPPayloadType);
+
+/**
+ * This function is used to remove rfc2833 dtmf detection capability.
+ * @param call             Handle to call, if disabling for the call, else NULL
+ *                         for end-point.
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityDisableDTMFRFC2833(struct OOH323CallData *call);
+
+
+/**
+ * This function is used to enable support for H.245 based alphanumeric dtmf 
+ * capability.
+ * @param call             Handle to call, if enabling for the call, else NULL
+ *                         for end-point.
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityEnableDTMFH245Alphanumeric(struct OOH323CallData *call);
+
+/**
+ * This function is used to disable support for H.245 based alphanumeric dtmf 
+ * capability.
+ * @param call             Handle to call, if disabling for the call, else NULL
+ *                         for end-point.
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityDisableDTMFH245Alphanumeric
+                                             (struct OOH323CallData *call);
+
+/**
+ * This function is used to enable support for H.245 based signal dtmf 
+ * capability.
+ * @param call             Handle to call, if enabling for the call, else NULL
+ *                         for end-point.
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityEnableDTMFH245Signal(struct OOH323CallData *call);
+
+/**
+ * This function is used to disable support for H.245 based signal dtmf 
+ * capability.
+ * @param call             Handle to call, if disabling for the call, else NULL
+ *                         for end-point.
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityDisableDTMFH245Signal(struct OOH323CallData *call);
+
+/**
+ * This function is used to enable support for dtmf using Q.931 Keypad IE.
+ * @param call             Handle to call, if enabling for the call, else NULL
+ *                         for end-point.
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityEnableDTMFQ931Keypad(struct OOH323CallData *call);
+
+/**
+ * This function is used to disable support for dtmf using Q.931 Keypad IE.
+ * @param call             Handle to call, if disabling for the call, else NULL
+ *                         for end-point.
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityDisableDTMFQ931Keypad(struct OOH323CallData *call);
+
+/**
+ * This function is used to add simple capabilities which have only rxframes
+ * and txframes parameters to the endpoint or call.(ex. G711, G728, G723.1, 
+ * G729)
+ * @param call                 Handle to a call. If this is not Null, then 
+ *                             capability is added to call's remote enpoint 
+ *                             capability list, else it is added to local H323 
+ *                             endpoint list.
+ * @param cap                  Type of G711 capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param silenceSuppression   Indicates support for silence suppression.
+ *                             Used only in case of g7231, otherwise ignored.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ * @param remote               TRUE, if adding call's remote capability.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCapabilityAddSimpleCapability
+   (struct OOH323CallData *call, int cap, int txframes, int rxframes, 
+    OOBOOL silenceSuppression, int dir, 
+    cb_StartReceiveChannel startReceiveChannel,
+    cb_StartTransmitChannel startTransmitChannel,
+    cb_StopReceiveChannel stopReceiveChannel,
+    cb_StopTransmitChannel stopTransmitChannel,
+    OOBOOL remote);
+
+
+/**
+ * This is an internal helper function which is used to add a GSM capability
+ * to local endpoints capability list or to remote endpoints capability list or
+ * to a call's capability list.
+ * @param call                 Handle to a call. If this is not Null, then 
+ *                             capability is added to call's remote enpoint 
+ *                             capability list, else it is added to local H323 
+ *                             endpoint list.
+ * @param cap                  Type of GSM capability to be added.
+ * @param framesPerPkt         Number of GSM frames per packet. 
+ * @param comfortNoise         Comfort noise spec for the capability. 
+ * @param scrambled            Scrambled enabled/disabled for the capability.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ * @param remote               TRUE, if adding call's remote capabilities.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+int ooCapabilityAddGSMCapability(struct OOH323CallData *call, int cap, 
+                                unsigned framesPerPkt, OOBOOL comfortNoise,
+                                OOBOOL scrambled, int dir, 
+                                cb_StartReceiveChannel startReceiveChannel,
+                                cb_StartTransmitChannel startTransmitChannel,
+                                cb_StopReceiveChannel stopReceiveChannel,
+                                cb_StopTransmitChannel stopTransmitChannel, 
+                                OOBOOL remote);
+
+
+/**
+ * This function is used to add H263 video capability to local endpoints 
+ * capability list or to remote endpoints capability list or to a call's 
+ * capability list.
+ * @param call                 Handle to a call. If this is not Null, then 
+ *                             capability is added to call's remote enpoint 
+ *                             capability list, else it is added to local H323 
+ *                             endpoint list.
+ * @param sqcifMPI             Minimum picture interval for encoding/decoding 
+ *                             of SQCIF pictures.
+ * @param qcifMPI              Minimum picture interval for encoding/decoding 
+ *                             of QCIF pictures.
+ * @param cifMPI               Minimum picture interval for encoding/decoding 
+ *                             of CIF pictures.
+ * @param cif4MPI              Minimum picture interval for encoding/decoding 
+ *                             of CIF4 pictures.
+ * @param cif16MPI             Minimum picture interval for encoding/decoding 
+ *                             of CIF16 pictures.
+ * @param maxBitRate           Maximum bit rate in units of 100 bits/s at
+ *                             which a transmitter can transmit video or a 
+ *                             receiver can receive video.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ * @param remote               TRUE, if adding call's remote capabilities.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooCapabilityAddH263VideoCapability(struct OOH323CallData *call, 
+                               unsigned sqcifMPI, unsigned qcifMPI, 
+                               unsigned cifMPI, unsigned cif4MPI, 
+                               unsigned cif16MPI, unsigned maxBitRate, int dir,
+                               cb_StartReceiveChannel startReceiveChannel,
+                               cb_StartTransmitChannel startTransmitChannel,
+                               cb_StopReceiveChannel stopReceiveChannel,
+                               cb_StopTransmitChannel stopTransmitChannel, 
+                               OOBOOL remote);
+
+
+/**
+ * This function is an helper function to ooCapabilityAddH263VideoCapability.
+ * @param call                 Handle to a call. If this is not Null, then 
+ *                             capability is added to call's remote enpoint 
+ *                             capability list, else it is added to local H323 
+ *                             endpoint list.
+ * @param sqcifMPI             Minimum picture interval for encoding/decoding 
+ *                             of SQCIF pictures.
+ * @param qcifMPI              Minimum picture interval for encoding/decoding 
+ *                             of QCIF pictures.
+ * @param cifMPI               Minimum picture interval for encoding/decoding 
+ *                             of CIF pictures.
+ * @param cif4MPI              Minimum picture interval for encoding/decoding 
+ *                             of CIF4 pictures.
+ * @param cif16MPI             Minimum picture interval for encoding/decoding 
+ *                             of CIF16 pictures.
+ * @param maxBitRate           Maximum bit rate in units of 100 bits/s at
+ *                             which a transmitter can transmit video or a 
+ *                             receiver can receive video.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ * @param remote               TRUE, if adding call's remote capabilities.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+int ooCapabilityAddH263VideoCapability_helper(struct OOH323CallData *call, 
+                              unsigned sqcifMPI, unsigned qcifMPI, 
+                              unsigned cifMPI, unsigned cif4MPI, 
+                              unsigned cif16MPI, unsigned maxBitRate, int dir, 
+                              cb_StartReceiveChannel startReceiveChannel,
+                              cb_StartTransmitChannel startTransmitChannel,
+                              cb_StopReceiveChannel stopReceiveChannel,
+                              cb_StopTransmitChannel stopTransmitChannel, 
+                              OOBOOL remote);
+
+/**
+ * This function is used to add a audio capability to calls remote  
+ * capability list.
+ * @param call                Handle to the call.
+ * @param audioCap            Handle to the remote endpoint's audio capability.
+ * @param dir                 Direction in which capability is supported by 
+ *                            remote endpoint.
+ *
+ * @return                    OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooAddRemoteAudioCapability(struct OOH323CallData *call,
+                               H245AudioCapability *audioCap, int dir);
+
+
+/**
+ * This function is used to add a capability to call's remote  capability list.
+ * The capabilities to be added are extracted from received TCS message.
+ * @param call           Handle to the call.
+ * @param cap            Handle to the remote endpoint's H245 capability.
+ *
+ * @return               OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooAddRemoteCapability(struct OOH323CallData *call, H245Capability *cap);
+
+/**
+ * This function is used to update joint capabilities for call. It checks
+ * whether remote capability can be supported by local capabilities for the
+ * call and if supported makes entry into the joint capability list for the 
+ * call.
+ * @param call           Handle to the call
+ * @param cap            Remote cap which will be tested for compatibility.
+ *
+ * @return               returns OO_OK, if updated else OO_FAILED;  
+ */
+EXTERN int ooCapabilityUpdateJointCapabilities
+   (struct OOH323CallData* call, H245Capability *cap);
+
+
+/**
+ * This function is used to update joint video capabilities for call. It checks
+ * whether remote capability can be supported by local capabilities for the
+ * call and if supported makes entry into the joint capability list for the 
+ * call.
+ * @param call           Handle to the call
+ * @param videoCap       Remote video capability which will be tested for 
+ *                       compatibility.
+ * @param dir            Direction of the capability
+ *
+ * @return               returns OO_OK, if updated else OO_FAILED;  
+ */
+EXTERN int ooCapabilityUpdateJointCapabilitiesVideo
+   (struct OOH323CallData *call, H245VideoCapability *videoCap, int dir);
+
+
+/**
+ * This function is used to update joint video H263 capabilities for call. It 
+ * checks whether remote capability can be supported by local capabilities for 
+ * the call and if supported makes entry into the joint capability list for the
+ * call.
+ * @param call           Handle to the call
+ * @param pH263Cap       Remote H263 video capability which will be tested for 
+ *                       compatibility.
+ * @param dir            Direction of the H263 capability
+ *
+ * @return               returns OO_OK, if updated else OO_FAILED;  
+ */
+EXTERN int ooCapabilityUpdateJointCapabilitiesVideoH263
+   (struct OOH323CallData *call, H245H263VideoCapability *pH263Cap, int dir);
+
+
+/**
+ * This function is used to test whether the endpoint capability in the 
+ * specified direction can be supported by the audio capability.
+ * @param call               Handle to the call.
+ * @param epCap              Endpoint capability.
+ * @param dataType           Data type with which compatibility has to 
+ *                           be tested.
+ * @param dir                Direction indicating whether endpoint capability
+ *                           will be used for transmission or reception.
+ *
+ * @return                   TRUE, if compatible. FALSE, otherwise. 
+ */
+
+ASN1BOOL ooCapabilityCheckCompatibility(struct OOH323CallData *call, 
+                                        ooH323EpCapability *epCap, 
+                                        H245DataType *dataType, int dir);
+
+
+/**
+ * This function is used to create a audio capability structure using the
+ * capability type.
+ * @param epCap       Capability.
+ * @param pctxt       Handle to OOCTXT which will be used to allocate memory 
+ *                    for new audio capability.
+ * @param dir         Direction in which the newly created capability will be 
+ *                    used.
+ *
+ * @return            Newly created audio capability on success, NULL on 
+ *                    failure.
+ */
+struct H245AudioCapability* ooCapabilityCreateAudioCapability 
+(ooH323EpCapability* epCap, OOCTXT *pctxt, int dir);
+
+/**
+ * This function is used to create a video capability structure using the
+ * capability type.
+ * @param epCap       Capability.
+ * @param pctxt       Handle to OOCTXT which will be used to allocate memory 
+ *                    for new video capability.
+ * @param dir         Direction in which the newly created capability will be 
+ *                    used.
+ *
+ * @return            Newly created video capability on success, NULL on 
+ *                    failure.
+ */
+struct H245VideoCapability* ooCapabilityCreateVideoCapability
+   (ooH323EpCapability *epCap, OOCTXT *pctxt, int dir);
+
+
+/**
+ * This function is used to create a dtmf capability which can be added to
+ * a TCS message.
+ * @param cap         Type of dtmf capability to be created.
+ * @param pctxt       Pointer to OOCTXT structure to be used for memory 
+ *                    allocation.
+ *
+ * @return            Pointer to the created DTMF capability, NULL in case of
+ *                    failure.
+ */
+void * ooCapabilityCreateDTMFCapability(int cap, OOCTXT *pctxt);
+
+
+/**
+ * This function is used to create a GSM Full Rate capability structure.
+ * @param epCap       Handle to the endpoint capability.
+ * @param pctxt       Handle to OOCTXT which will be used to allocate memory
+ *                    for new audio capability.
+ * @param dir         Direction for the newly created capability.
+ *
+ * @return            Newly created audio capability on success, NULL on 
+ *                    failure.
+ */
+struct H245AudioCapability* ooCapabilityCreateGSMFullRateCapability
+   (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir);
+
+/**
+ * This function is used to create a simple(g711, g728, g723.1, g729) audio 
+ * capability structure.
+ *
+ * @param epCap       Handle to the endpoint capability
+ * @param pctxt       Handle to OOCTXT which will be used to allocate memory 
+ *                    for new audio capability.
+ * @param dir         Direction in which the newly created capability will be 
+ *                    used.
+ *
+ * @return            Newly created audio capability on success, NULL on 
+ *                    failure.
+ */
+struct H245AudioCapability* ooCapabilityCreateSimpleCapability
+   (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir);
+
+
+/**
+ * This function is used to create a H263 video capability 
+ * structure.
+ * @param epCap       Handle to the endpoint capability
+ * @param pctxt       Handle to OOCTXT which will be used to allocate memory 
+ *                    for new video capability.
+ * @param dir         Direction in which the newly created capability will be 
+ *                    used.
+ *
+ * @return            Newly created video capability on success, NULL on 
+ *                    failure.
+ */
+struct H245VideoCapability* ooCapabilityCreateH263VideoCapability
+(ooH323EpCapability *epCap, OOCTXT* pctxt, int dir);
+
+
+/**
+ * This function is used to determine whether a particular capability
+ * can be supported by the endpoint.
+ * @param call       Handle to the call.
+ * @param audioCap   Handle to the audio capability.
+ * @param dir        Direction in which support is desired. 
+ *
+ * @return          Handle to the copyof capability which supports audioCap, 
+ *                  Null if none found
+ */
+ooH323EpCapability* ooIsAudioDataTypeSupported
+(struct OOH323CallData *call, H245AudioCapability* audioCap, int dir);
+
+/**
+ * This function is used to determine whether a particular video capability
+ * can be supported by the endpoint.
+ * @param call       Handle to the call.
+ * @param pVideoCap  Handle to the  video capability.
+ * @param dir        Direction in which support is desired. 
+ *
+ * @return          Handle to the copy of capability which supports video 
+ *                  capability, Null if none found
+ */
+ooH323EpCapability* ooIsVideoDataTypeSupported
+   (struct OOH323CallData *call, H245VideoCapability* pVideoCap, int dir);
+
+/**
+ * This function is used to determine whether a particular H263 capability
+ * can be supported by the endpoint.
+ * @param call       Handle to the call.
+ * @param pH263Cap   Handle to the H263 video capability.
+ * @param dir        Direction in which support is desired. 
+ * @param picFormat  Picture type(cif, qcif etc.)
+ *
+ * @return          Handle to the copy of capability which supports H263 
+ *                  capability, Null if none found
+ */
+ooH323EpCapability* ooIsVideoDataTypeH263Supported
+   (struct OOH323CallData *call, H245H263VideoCapability* pH263Cap, int dir, 
+    OOPictureFormat picFormat);
+
+/**
+ * This function is used to determine whether a particular capability type
+ * can be supported by the endpoint.
+ * @param call       Handle to the call.
+ * @param data       Handle to the capability type.
+ * @param dir        Direction in which support is desired. 
+ *
+ * @return          Handle to the copy of capability which supports specified 
+ *                  capability type, Null if none found
+ */
+ooH323EpCapability* ooIsDataTypeSupported
+(struct OOH323CallData *call, H245DataType *data, int dir);
+
+/**
+ * This function is used to clear the capability preference order.
+ * @param call      Handle to call, if capability preference order for call
+ *                  has to be cleared, NULL for endpoint.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN  int ooResetCapPrefs(struct OOH323CallData *call);
+
+/**
+ * This function is used to remove a particular capability from preference
+ * list.
+ * @param call     Handle to call, if call's preference list has to be modified
+ *                 else NULL, to modify endpoint's preference list.
+ * @param cap      Capability to be removed
+ *
+ * @return         OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN  int ooRemoveCapFromCapPrefs(struct OOH323CallData *call, int cap);
+
+/**
+ * This function is used to append a particular capability to preference
+ * list.
+ * @param call     Handle to call, if call's preference list has to be modified
+ *                 else NULL, to modify endpoint's preference list.
+ * @param cap      Capability to be appended.
+ *
+ * @return         OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooAppendCapToCapPrefs(struct OOH323CallData *call, int cap);
+
+/**
+ * This function is used to change preference order of a particular capability 
+ * in the preference list.
+ * @param call     Handle to call, if call's preference list has to be modified
+ *                 else NULL, to modify endpoint's preference list.
+ * @param cap      Capability concerned
+ * @param pos      New position in the preference order
+ *
+ * @return         OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooChangeCapPrefOrder(struct OOH323CallData *call, int cap, int pos);
+
+/**
+ * This function is used to preppend a particular capability to preference
+ * list.
+ * @param call     Handle to call, if call's preference list has to be modified
+ *                 else NULL, to modify endpoint's preference list.
+ * @param cap      Capability to be preppended.
+ *
+ * @return         OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooPreppendCapToCapPrefs(struct OOH323CallData *call, int cap);
+
+/**
+ * This function is used to retrieve the text description for a capability
+ * type.
+ * @param cap     Capability
+ * @return        The text description string.
+ */
+EXTERN const char* ooGetCapTypeText (OOCapabilities cap);
+
+
+/** 
+ * @} 
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
diff --git a/addons/ooh323c/src/ooCmdChannel.c b/addons/ooh323c/src/ooCmdChannel.c
new file mode 100644
index 000000000..8dfd01376
--- /dev/null
+++ b/addons/ooh323c/src/ooCmdChannel.c
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooStackCmds.h"
+#include "ootrace.h"
+#include "ooq931.h"
+#include "ooh245.h"
+#include "ooh323ep.h"
+#include "oochannels.h"
+#include "ooCalls.h"
+#include "ooCmdChannel.h"
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+OOSOCKET gCmdChan = 0;
+pthread_mutex_t gCmdChanLock;
+
+int ooCreateCmdConnection()
+{
+   int ret = 0;
+   int thePipe[2];
+
+   if ((ret = pipe(thePipe)) == -1) {
+      return OO_FAILED;
+   }
+   pthread_mutex_init(&gCmdChanLock, NULL);
+
+   gH323ep.cmdSock = dup(thePipe[0]);
+   close(thePipe[0]);
+   gCmdChan = dup(thePipe[1]);
+   close(thePipe[1]);
+   return OO_OK;
+}
+
+
+int ooCloseCmdConnection()
+{
+   close(gH323ep.cmdSock);
+   gH323ep.cmdSock = 0;
+   close(gCmdChan);
+   gCmdChan = 0;
+   pthread_mutex_destroy(&gCmdChanLock);
+
+   return OO_OK;
+}
+
+int ooWriteStackCommand(OOStackCommand *cmd)
+{
+
+	pthread_mutex_lock(&gCmdChanLock);
+   	if (write(gCmdChan, (char*)cmd, sizeof(OOStackCommand)) == -1) {
+		pthread_mutex_unlock(&gCmdChanLock);
+		return OO_FAILED;
+	}
+	pthread_mutex_unlock(&gCmdChanLock);
+   
+   	return OO_OK;
+}
+
+
+int ooReadAndProcessStackCommand()
+{
+   OOH323CallData *pCall = NULL;   
+   unsigned char buffer[MAXMSGLEN];
+   int i, recvLen = 0;
+   OOStackCommand cmd;
+   memset(&cmd, 0, sizeof(OOStackCommand));
+   recvLen = read(gH323ep.cmdSock, buffer, MAXMSGLEN);
+   if(recvLen <= 0)
+   {
+      OOTRACEERR1("Error:Failed to read CMD message\n");
+      return OO_FAILED;
+   }
+
+   for(i=0; (int)(i+sizeof(OOStackCommand)) <= recvLen; i += sizeof(OOStackCommand))
+   {
+      memcpy(&cmd, buffer+i, sizeof(OOStackCommand));
+
+      if(cmd.type == OO_CMD_NOOP)
+         continue;
+
+      if(gH323ep.gkClient && gH323ep.gkClient->state != GkClientRegistered)
+      {
+         OOTRACEINFO1("Ignoring stack command as Gk Client is not registered"
+                      " yet\n");
+      }
+      else {
+         switch(cmd.type) {
+            case OO_CMD_MAKECALL: 
+               OOTRACEINFO2("Processing MakeCall command %s\n", 
+                                    (char*)cmd.param2);
+ 
+               ooH323MakeCall ((char*)cmd.param1, (char*)cmd.param2, 
+                               (ooCallOptions*)cmd.param3);
+               break;
+
+            case OO_CMD_MANUALRINGBACK:
+               if(OO_TESTFLAG(gH323ep.flags, OO_M_MANUALRINGBACK))
+               {
+                  pCall = ooFindCallByToken((char*)cmd.param1);
+                  if(!pCall) {
+                     OOTRACEINFO2("Call \"%s\" does not exist\n",
+                                  (char*)cmd.param1);
+                     OOTRACEINFO1("Call migth be cleared/closed\n");
+                  }
+                  else {
+                     ooSendAlerting(ooFindCallByToken((char*)cmd.param1));
+                     if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER)) {
+                        ooSendConnect(ooFindCallByToken((char*)cmd.param1));
+                     }
+                  }
+               }
+               break;
+ 
+            case OO_CMD_ANSCALL:
+               pCall = ooFindCallByToken((char*)cmd.param1);
+               if(!pCall) {
+                  OOTRACEINFO2("Call \"%s\" does not exist\n",
+                               (char*)cmd.param1);
+                  OOTRACEINFO1("Call might be cleared/closed\n");
+               }
+               else {
+                  OOTRACEINFO2("Processing Answer Call command for %s\n",
+                               (char*)cmd.param1);
+                  ooSendConnect(pCall);
+               }
+               break;
+
+            case OO_CMD_FWDCALL:
+               OOTRACEINFO3("Forwarding call %s to %s\n", (char*)cmd.param1,
+                                                          (char*)cmd.param2);
+               ooH323ForwardCall((char*)cmd.param1, (char*)cmd.param2);
+               break;
+
+            case OO_CMD_HANGCALL: 
+               OOTRACEINFO2("Processing Hang call command %s\n", 
+                             (char*)cmd.param1);
+               ooH323HangCall((char*)cmd.param1, 
+                              *(OOCallClearReason*)cmd.param2);
+               break;
+          
+            case OO_CMD_SENDDIGIT:
+               pCall = ooFindCallByToken((char*)cmd.param1);
+               if(!pCall) {
+                  OOTRACEERR2("ERROR:Invalid calltoken %s\n",
+                              (char*)cmd.param1);
+                  break;
+               }
+               if(pCall->jointDtmfMode & OO_CAP_DTMF_H245_alphanumeric) {
+                  ooSendH245UserInputIndication_alphanumeric(
+                     pCall, (const char*)cmd.param2);
+               }
+               else if(pCall->jointDtmfMode & OO_CAP_DTMF_H245_signal) {
+                  ooSendH245UserInputIndication_signal(
+                     pCall, (const char*)cmd.param2);
+               }
+               else {
+                  ooQ931SendDTMFAsKeyPadIE(pCall, (const char*)cmd.param2);
+               }
+
+               break;
+
+            case OO_CMD_STOPMONITOR: 
+               OOTRACEINFO1("Processing StopMonitor command\n");
+               ooStopMonitorCalls();
+               break;
+
+            default: OOTRACEERR1("ERROR:Unknown command\n");
+         }
+      }
+      if(cmd.param1) free(cmd.param1);
+      if(cmd.param2) free(cmd.param2);
+      if(cmd.param3) free(cmd.param3);
+   }
+
+
+   return OO_OK;
+}
+   
diff --git a/addons/ooh323c/src/ooCmdChannel.h b/addons/ooh323c/src/ooCmdChannel.h
new file mode 100644
index 000000000..cc1dfaa25
--- /dev/null
+++ b/addons/ooh323c/src/ooCmdChannel.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file ooCmdChannel.h 
+ * This file contains stack commands which an user application can use to make
+ * call, hang call etc. 
+ */
+
+#ifndef OO_CMDCHANNEL_H
+#define OO_CMDCHANNEL_H
+
+#include "ootypes.h"
+#include "ooStackCmds.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#if defined (MAKE_DLL)
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+
+#define OO_DEFAULT_CMDLISTENER_PORT 7575
+
+/**
+ * @addtogroup channels 
+ * @{
+ */
+
+/**
+ * This function is used to setup a command connection with the main stack 
+ * thread. The application commands are sent over this connection to stack 
+ * thread.
+ *
+ * @return          OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooCreateCmdConnection();
+
+/**
+ * This function is used to close a command channel setup with the stack 
+ * thread.
+ *
+ * @return          OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooCloseCmdConnection();
+
+
+/**
+ * This function is used by stack api to write stack commands to command 
+ * channel.
+ *
+ * @return          OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooWriteStackCommand(OOStackCommand *cmd);
+
+/**
+ * This function is used by stack thread to read and process stack commands 
+ * received over command channel.
+ *
+ * @return          OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooReadAndProcessStackCommand();
+
+
+/** 
+ * @} 
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/ooCommon.h b/addons/ooh323c/src/ooCommon.h
new file mode 100644
index 000000000..bb034c569
--- /dev/null
+++ b/addons/ooh323c/src/ooCommon.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the LICENSE.txt file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/** 
+ * @file ooCommon.h 
+ * Common runtime constant and type definitions.
+ */
+#ifndef _OOCOMMON_H_
+#define _OOCOMMON_H_
+
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef _WIN32_WCE
+#include <winsock.h>
+#elif defined(_WIN32) || defined(_WIN64)
+#include <sys/types.h>
+#define INCL_WINSOCK_API_TYPEDEFS   1
+#define INCL_WINSOCK_API_PROTOTYPES 0
+#include <winsock2.h>
+#else
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#endif
+
+/** 
+ * @ingroup cruntime C Runtime Common Constant and Type Definitions.
+ * @{
+ */
+
+/* Basic type definitions */
+
+typedef char            OOCHAR;
+typedef unsigned char   OOUCHAR;
+typedef signed char     OOINT8;
+typedef unsigned char   OOUINT8;
+typedef short           OOINT16;
+typedef unsigned short  OOUINT16;
+typedef int             OOINT32;
+typedef unsigned int    OOUINT32;
+typedef OOUINT8         OOBOOL;
+
+#define OOUINT32_MAX    4294967295U
+#define OOINT32_MAX     ((OOINT32)2147483647L)
+#define OOINT32_MIN     ((OOINT32)(-OOINT32_MAX-1))
+
+#ifndef FALSE
+#define FALSE           0
+#define TRUE            1
+#endif
+
+/* Common error codes */
+
+#define OOERRINVPARAM   (-50)   /* Invalid parameter    */
+#define OOERRBUFOVFLW   (-51)   /* Buffer overflow      */
+#define OOERRNOMEM      (-52)   /* No dynamic memory available */
+
+/* Message buffer: this is used for asynchronous transfers */
+
+typedef struct _OOMsgBuf {
+   OOUINT8* pdata;      /* Pointer to binary or text data               */
+   OOUINT32 bufsiz;     /* Size of the buffer in bytes                  */
+   OOUINT32 length;     /* # bytes to send (write) or # received (read) */
+   OOUINT32 offset;     /* Offset into buffer of first byte to send     */
+   OOBOOL   dynamic;    /* pdata is dynamic (allocated with OOMEMALLOC) */
+} OOMsgBuf;
+
+/* Memory allocation and free function definitions.  These definitions  */
+/* can be changed if a non-standard allocation/free function is to be   */
+/* used..                                                               */
+
+#define OOMEMALLOC  malloc
+#define OOMEMFREE   free
+
+/* Min/max macros */
+
+#ifndef OOMAX
+#define OOMAX(a,b)  (((a)>(b))?(a):(b))
+#endif
+
+#ifndef OOMIN
+#define OOMIN(a,b)  (((a)<(b))?(a):(b))
+#endif
+
+/* Get count of number of items in an array */
+
+#define OONUMBEROF(items) (sizeof(items)/sizeof(items[0]))
+
+/* This is used for creating a Windows DLL.  Specify -DMAKE_DLL to      */
+/* compile code for inclusion in a DLL.                                 */
+
+#ifndef EXTERN
+#if defined (MAKE_DLL)
+#define EXTERN __declspec(dllexport)
+#elif defined (USE_DLL)
+#define EXTERN __declspec(dllimport)
+#else
+#define EXTERN
+#endif /* _DLL */
+#endif /* EXTERN */
+
+/** 
+ * @} 
+ */
+#endif /* _OOCOMMON_H_ */
diff --git a/addons/ooh323c/src/ooDateTime.c b/addons/ooh323c/src/ooDateTime.c
new file mode 100644
index 000000000..af6faec65
--- /dev/null
+++ b/addons/ooh323c/src/ooDateTime.c
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the LICENSE.txt file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooCommon.h"
+
+#if defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+
+#ifndef __MINGW32__
+#include <SYS\TIMEB.H>
+int gettimeofday (struct timeval *tv, struct timezone *tz)
+{
+   struct _timeb currSysTime;
+   _ftime(&currSysTime);
+
+   tv->tv_sec = currSysTime.time;
+   tv->tv_usec = currSysTime.millitm * 1000;
+
+   return 0;
+}
+
+#else
+/* Mingw specific logic..probably works with regular winders
+ * too, but cannot test. --Ben
+ */
+#define uint64 unsigned long long
+#define uint32 unsigned long
+
+static uint64 calcEpocOffset() {
+   SYSTEMTIME st;
+   FILETIME ft;
+
+   memset(&st, 0, sizeof(st));
+   memset(&ft, 0, sizeof(ft));
+
+   st.wYear = 1970;
+   st.wMonth = 1;
+   st.wDayOfWeek = 0;
+   st.wDay = 1;
+   st.wHour = 0;
+   st.wMinute = 0;
+   st.wSecond = 0;
+   st.wMilliseconds = 0;
+
+   if (!SystemTimeToFileTime(&st, &ft)) {
+      //cout << "ERROR:  SystemTimeToFileTime failed, err: "
+      //       << GetLastError() << endl;
+   }
+
+   uint64 t = ft.dwHighDateTime;
+   t = t << 32;
+   t |= ft.dwLowDateTime;
+
+   return t;
+}
+
+// Gets high resolution by spinning up to 15ms.  Don't call this often!!!
+static uint64 getRawCurMsSpin() {
+   FILETIME tm;   
+   uint64 t_now;
+
+   static uint64 epocOffset = 0;
+   static int do_once = 1;
+   if (do_once) {
+      epocOffset = calcEpocOffset();
+      do_once = 0;
+   }
+
+   GetSystemTimeAsFileTime(&tm);
+   uint64 t_start = tm.dwHighDateTime;
+   t_start = t_start << 32;
+   t_start |= tm.dwLowDateTime;
+   while (1) {
+      GetSystemTimeAsFileTime(&tm);
+      t_now = tm.dwHighDateTime;
+      t_now = t_now << 32;
+      t_now |= tm.dwLowDateTime;
+
+      if (t_now != t_start) {
+         // Hit a boundary...as accurate as we are going to get.
+         break;
+      }
+   }
+
+
+   t_now -= epocOffset;
+
+   // t is in 100ns units, convert to usecs
+   t_now = t_now / 10000; //msecs
+
+   return t_now;
+}
+
+static uint64 baselineMs = 0;
+static uint32 tickBaseline = 0;
+
+int gettimeofday(struct timeval* tv, void* null) {
+
+   // Get baseline time, in seconds.
+   if (baselineMs == 0) {
+      baselineMs = getRawCurMsSpin();
+      tickBaseline = timeGetTime();
+   }
+
+   uint32 curTicks = timeGetTime();
+   if (curTicks < tickBaseline) {
+      // Wrap!
+      baselineMs = getRawCurMsSpin();
+      tickBaseline = timeGetTime();
+   }
+   
+   uint64 now_ms = (baselineMs + (curTicks - tickBaseline));
+   *tv = oo_ms_to_tv(now_ms);
+   return 0;
+};
+
+
+/* Correctly synched with the 'real' time/date clock, but only exact to
+ * about 15ms.  Set foo to non NULL if you want to recalculate the
+ */
+uint64 getCurMsFromClock() {
+   // This has resolution of only about 15ms
+   FILETIME tm;
+   // The Windows epoc is January 1, 1601 (UTC).
+   static uint64 offset = 0;
+   static int do_once = 1;
+   if (do_once) {
+      offset = calcEpocOffset();
+      do_once = 0;
+   }
+
+
+   GetSystemTimeAsFileTime(&tm);
+   uint64 t = tm.dwHighDateTime;
+   t = t << 32;
+   t |= tm.dwLowDateTime;
+
+   /*cout << "file-time: " << t << " offset: " << offset
+          << " normalized: " << (t - offset) << " hi: "
+          << tm.dwHighDateTime << " lo: " << tm.dwLowDateTime
+          << " calc-offset:\n" << calcEpocOffset() << "\n\n";
+   */
+   t -= offset;
+
+   // t is in 100ns units, convert to ms
+   t = t / 10000;
+   return t;
+}
+#endif
+#endif
+
+int ooGetTimeOfDay (struct timeval *tv, struct timezone *tz)
+{
+   return gettimeofday (tv, tz);
+}
+
+
+long ooGetTimeDiff(struct timeval *tv1, struct timeval *tv2)
+{
+   return ( ((tv2->tv_sec-tv1->tv_sec)*1000) + 
+            ((tv2->tv_usec-tv1->tv_usec)/1000) );
+}
+
diff --git a/addons/ooh323c/src/ooDateTime.h b/addons/ooh323c/src/ooDateTime.h
new file mode 100644
index 000000000..afcc9b308
--- /dev/null
+++ b/addons/ooh323c/src/ooDateTime.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the LICENSE.txt file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/** 
+ * @file ooDateTime.h 
+ * Time functions that reconcile differences between Windows and UNIX.
+ */
+#ifndef _OOTIME_H_
+#define _OOTIME_H_
+
+#include "ooCommon.h"
+#include <time.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * This function provides an abstraction for the UNIX 'gettimeofday' 
+ * function which is not available on Windows.
+ *
+ * @param tv           Pointer to time value structure to receive 
+ *                     current time value.
+ * @param tz           Point to time zone information.
+ * @return             Completion status of operation: 0 = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooGetTimeOfDay (struct timeval *tv, struct timezone *tz);
+
+/**
+ * This function subtracts first timeval parameter from second and provides
+ * the difference in milliseconds.
+ * @param tv1          Pointer to timeval value.
+ * @param tv2          Pointer to timeval value.
+ *
+ * @return             Difference between two timevals in milliseconds.
+ */
+EXTERN long ooGetTimeDiff(struct timeval *tv1, struct timeval *tv2);
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/addons/ooh323c/src/ooGkClient.c b/addons/ooh323c/src/ooGkClient.c
new file mode 100644
index 000000000..1a920e3a7
--- /dev/null
+++ b/addons/ooh323c/src/ooGkClient.c
@@ -0,0 +1,2443 @@
+/*
+ * Copyright (C) 2005 by Page Iberica, S.A.
+ * Copyright (C) 2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/**
+ * @file ooGkClient.c 
+ * This file contains functions to support RAS protocol. 
+ *
+ */
+#include "ooGkClient.h"
+#include "ootypes.h"
+#include "ootrace.h"
+#include "ooports.h"
+#include "ooasn1.h"
+#include "oochannels.h"
+#include "printHandler.h"
+#include "ooCalls.h"
+#include "H323-MESSAGES.h"
+#include "ooDateTime.h"
+#include "ooq931.h"
+#include "ooh323.h"
+#include "ooh323ep.h"
+#include "ooTimer.h"
+#include "ooSocket.h"
+#include "ooUtils.h"
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+static ASN1OBJID gProtocolID = {
+   6, { 0, 0, 8, 2250, 0, 4 }
+};
+
+int ooGkClientInit(enum RasGatekeeperMode eGkMode,
+              char *szGkAddr, int iGkPort )
+{
+   ooGkClient *pGkClient=NULL;
+   OOInterface *cur=NULL;
+   pGkClient = (ooGkClient*)
+                         memAlloc(&gH323ep.ctxt, sizeof(ooGkClient));
+   if(!pGkClient)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory to Gatekeeper Client.\n");
+      return OO_FAILED;
+   }
+ 
+   memset(pGkClient, 0, sizeof(ooGkClient));
+   gH323ep.gkClient = pGkClient;
+   initContext(&(pGkClient->ctxt));
+   initContext(&(pGkClient->msgCtxt));
+   pGkClient->rrqRetries = 0;
+   pGkClient->grqRetries = 0;
+
+   strcpy(pGkClient->localRASIP, gH323ep.signallingIP);
+#ifndef _WIN32
+   if(!strcmp(pGkClient->localRASIP, "0.0.0.0") ||
+      !strcmp(pGkClient->localRASIP, "127.0.0.1"))
+   {
+      if(!gH323ep.ifList)
+      {
+         if(ooSocketGetInterfaceList(&gH323ep.ctxt, &gH323ep.ifList)!= ASN_OK)
+         {
+            OOTRACEERR1("Error:Failed to retrieve interface addresses\n");
+            return OO_FAILED;
+         }
+      }
+      for(cur = gH323ep.ifList; cur; cur = cur->next)
+      {
+         if(!strcmp(cur->name, "lo") || !strcmp(cur->addr, "127.0.0.1"))
+            continue;
+         break;
+      }
+      if(cur)
+      {
+         OOTRACEINFO2("Using local RAS Ip address %s\n", cur->addr);
+         strcpy(pGkClient->localRASIP, cur->addr);
+      }
+      else{
+         OOTRACEERR1("Error:Failed to assign a local RAS IP address\n");
+         return OO_FAILED;
+      }
+   }
+#endif   
+   if(OO_OK != ooGkClientSetGkMode(pGkClient, eGkMode, szGkAddr, iGkPort))
+   {
+      OOTRACEERR1("Error:Failed to set Gk mode\n");
+      memReset(&gH323ep.ctxt);
+      return OO_FAILED;
+   }
+  
+   /* Create default parameter set */
+   pGkClient->grqTimeout = DEFAULT_GRQ_TIMEOUT;
+   pGkClient->rrqTimeout = DEFAULT_RRQ_TIMEOUT;
+   pGkClient->regTimeout = DEFAULT_REG_TTL;
+   pGkClient->arqTimeout = DEFAULT_ARQ_TIMEOUT;
+   pGkClient->drqTimeout = DEFAULT_DRQ_TIMEOUT;
+   dListInit(&pGkClient->callsPendingList);
+   dListInit(&pGkClient->callsAdmittedList);
+   dListInit(&pGkClient->timerList);
+   pGkClient->state = GkClientIdle;
+   return OO_OK;
+}
+
+
+int ooGkClientSetCallbacks
+   (ooGkClient *pGkClient, OOGKCLIENTCALLBACKS callbacks)
+{
+   pGkClient->callbacks.onReceivedRegistrationConfirm = 
+                                      callbacks.onReceivedRegistrationConfirm;
+   pGkClient->callbacks.onReceivedUnregistrationConfirm = 
+                                     callbacks.onReceivedUnregistrationConfirm;
+   pGkClient->callbacks.onReceivedUnregistrationRequest = 
+                                     callbacks.onReceivedUnregistrationRequest;
+   return OO_OK;
+}
+
+int ooGkClientReInit(ooGkClient *pGkClient)
+{
+
+   ooGkClientCloseChannel(pGkClient);
+   pGkClient->gkRasIP[0]='\0';
+   pGkClient->gkCallSignallingIP[0]='\0';
+   pGkClient->gkRasPort = 0;
+   pGkClient->gkCallSignallingPort = 0;
+   pGkClient->rrqRetries = 0;
+   pGkClient->grqRetries = 0;
+   pGkClient->requestSeqNum = 0;
+   
+   dListFreeAll(&pGkClient->ctxt, &pGkClient->callsPendingList);
+   dListFreeAll(&pGkClient->ctxt, &pGkClient->callsAdmittedList);
+   dListFreeAll(&pGkClient->ctxt, &pGkClient->timerList);
+   pGkClient->state = GkClientIdle;
+   return OO_OK;
+}
+
+void ooGkClientPrintConfig(ooGkClient *pGkClient)
+{
+   OOTRACEINFO1("Gatekeeper Client Configuration:\n");
+   if(pGkClient->gkMode == RasUseSpecificGatekeeper)
+   {
+      OOTRACEINFO1("\tGatekeeper mode - UseSpecificGatekeeper\n");
+      OOTRACEINFO3("\tGatekeeper To Use - %s:%d\n", pGkClient->gkRasIP, 
+                                                    pGkClient->gkRasPort);
+   }
+   else if(pGkClient->gkMode == RasDiscoverGatekeeper) {
+      OOTRACEINFO1("\tGatekeeper mode - UseSpecificGatekeeper\n");
+   }
+   else {
+      OOTRACEERR1("Invalid GatekeeperMode\n");
+   }
+}
+
+int ooGkClientDestroy(void)
+{
+   if(gH323ep.gkClient)
+   {
+      if(gH323ep.gkClient->state == GkClientRegistered)
+      {
+         OOTRACEINFO1("Unregistering from Gatekeeper\n");
+         if(ooGkClientSendURQ(gH323ep.gkClient, NULL)!=OO_OK)
+            OOTRACEERR1("Error:Failed to send URQ to gatekeeper\n");
+      }
+      OOTRACEINFO1("Destroying Gatekeeper Client\n");
+      ooGkClientCloseChannel(gH323ep.gkClient);
+      freeContext(&gH323ep.gkClient->msgCtxt);
+      freeContext(&gH323ep.gkClient->ctxt);
+      memFreePtr(&gH323ep.ctxt, gH323ep.gkClient);
+      gH323ep.gkClient = NULL;
+   }
+   return OO_OK;
+}
+
+int ooGkClientStart(ooGkClient *pGkClient)
+{
+   int iRet=0;
+   iRet = ooGkClientCreateChannel(pGkClient);
+
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error: GkClient Channel Creation failed\n");
+      return OO_FAILED;
+   }
+   
+   pGkClient->discoveryComplete = FALSE;
+   iRet = ooGkClientSendGRQ(pGkClient);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error:Failed to send GRQ message\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   return OO_OK;
+}
+   
+
+int ooGkClientSetGkMode(ooGkClient *pGkClient, enum RasGatekeeperMode eGkMode, 
+                        char *szGkAddr, int iGkPort )
+{
+   pGkClient->gkMode = eGkMode;
+   if(eGkMode == RasUseSpecificGatekeeper)
+   {
+      OOTRACEINFO1("Gatekeeper Mode - RasUseSpecificGatekeeper\n");
+      if(szGkAddr)
+      {
+         if(strlen(szGkAddr)>MAX_IP_LEN)
+         { 
+            OOTRACEERR2("Error:Invalid IP address specified - %s\n", szGkAddr);
+            return OO_FAILED;
+         }
+         strcpy(pGkClient->gkRasIP, szGkAddr);
+      }
+      if(iGkPort)
+         pGkClient->gkRasPort = iGkPort;
+      else
+         pGkClient->gkRasPort = DEFAULT_GKPORT;
+
+      OOTRACEINFO3("Gatekeeper IP:port set to - %s:%d\n", 
+                    szGkAddr,  pGkClient->gkRasPort);
+   }
+   else if(eGkMode == RasDiscoverGatekeeper) {
+      OOTRACEINFO1("Gatekeeper Mode - RasDiscoverGatekeeper\n");
+   }
+   else if(eGkMode == RasNoGatekeeper) {
+      OOTRACEINFO1("Gatekeeper Mode - RasNoGatekeeper\n");
+   }
+   return OO_OK;
+}
+
+   
+/**
+ * Create the RAS channel (socket).
+ *
+ */
+
+int ooGkClientCreateChannel(ooGkClient *pGkClient)
+{
+   int ret=0;
+   OOIPADDR ipaddrs;
+   /* Create socket */
+   if((ret=ooSocketCreateUDP(&pGkClient->rasSocket))!=ASN_OK)
+   {
+      OOTRACEERR1("Failed to create RAS socket\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   if(pGkClient->localRASPort)
+   {
+      ret= ooSocketStrToAddr (pGkClient->localRASIP, &ipaddrs);
+      if( (ret=ooSocketBind( pGkClient->rasSocket, ipaddrs, 
+           pGkClient->localRASPort))!=ASN_OK ) 
+      {
+         OOTRACEERR1("ERROR:Failed to create RAS channel\n");
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      }
+   }
+   else {
+      ret = ooBindPort (OOUDP, pGkClient->rasSocket, pGkClient->localRASIP);
+      if(ret == OO_FAILED)
+      {
+         OOTRACEERR1("ERROR: Failed to bind port to RAS socket\n");
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      }
+      pGkClient->localRASPort = ret;
+   }
+   /* Test Code NOTE- This doesn't work..:(( Have to fix this */
+   /* If multihomed, get ip from socket */
+   if(!strcmp(pGkClient->localRASIP, "0.0.0.0"))
+   {
+      OOTRACEDBGA1("Determining ip address for RAS channel "
+                   "multihomed mode. \n");
+      ret = ooSocketGetIpAndPort(pGkClient->rasSocket, pGkClient->localRASIP, 
+                                 20, &pGkClient->localRASPort);
+      if(ret != ASN_OK)
+      {
+         OOTRACEERR1("Error:Failed to retrieve local ip and port from "
+                     "socket for RAS channel(multihomed).\n");
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      }
+      OOTRACEDBGA3("Using local ip %s and port %d for RAS channel"
+                   "(multihomedMode).\n", pGkClient->localRASIP, 
+                   pGkClient->localRASPort);
+   }
+   /* End of Test code */
+   OOTRACEINFO1("H323 RAS channel creation - successful\n");
+   return OO_OK;
+}
+
+
+int ooGkClientCloseChannel(ooGkClient *pGkClient)
+{
+   int ret;
+   if(pGkClient->rasSocket != 0)
+   {
+      ret = ooSocketClose(pGkClient->rasSocket);
+      if(ret != ASN_OK)
+      {
+         OOTRACEERR1("Error: failed to close RAS channel\n");
+         pGkClient->rasSocket = 0;
+         return OO_FAILED;
+      }
+      pGkClient->rasSocket = 0;
+   }
+   OOTRACEINFO1("Closed RAS channel\n");
+   return OO_OK;
+}
+
+
+/**
+ * Fill vendor data in RAS message structure.
+ */
+
+void ooGkClientFillVendor
+   (ooGkClient *pGkClient, H225VendorIdentifier *pVendor )
+{
+   pVendor->vendor.t35CountryCode = gH323ep.t35CountryCode;
+   pVendor->vendor.t35Extension = gH323ep.t35Extension;
+   pVendor->vendor.manufacturerCode = gH323ep.manufacturerCode;
+   pVendor->enterpriseNumber.numids=0;
+   if(gH323ep.productID)
+   {
+      pVendor->m.productIdPresent = TRUE;
+      pVendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), 
+                                             sizeof(pVendor->productId.data));
+      memcpy(pVendor->productId.data, gH323ep.productID, 
+                                                  pVendor->productId.numocts);
+   }
+   if(gH323ep.versionID)
+   {
+      pVendor->m.versionIdPresent = 1;
+      pVendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), 
+                                             sizeof(pVendor->versionId.data));
+      memcpy(pVendor->versionId.data, gH323ep.versionID, 
+                                                 pVendor->versionId.numocts); 
+   }
+}   
+
+
+int ooGkClientReceive(ooGkClient *pGkClient)
+{
+   ASN1OCTET recvBuf[1024];
+   int recvLen;
+   char remoteHost[32];
+   int iFromPort=0;
+   OOCTXT *pctxt=NULL;
+   H225RasMessage *pRasMsg=NULL;
+   int iRet=OO_OK;
+   
+   pctxt = &pGkClient->msgCtxt;
+
+   recvLen = ooSocketRecvFrom(pGkClient->rasSocket, recvBuf, 1024, remoteHost,
+                              32, &iFromPort);
+   if(recvLen <0)
+   {
+      OOTRACEERR1("Error:Failed to receive RAS message\n");
+      return OO_FAILED;
+   }
+   OOTRACEDBGA1("GkClient Received RAS Message\n");
+  
+   /* Verify the gk */
+   if(pGkClient->discoveryComplete)
+   {
+      if((strncmp(pGkClient->gkRasIP, remoteHost,strlen(pGkClient->gkRasIP)))||
+         (pGkClient->gkRasPort!= iFromPort) )
+      {
+         OOTRACEWARN3("WARN:Ignoring message received from unknown gatekeeper "
+                      "%s:%d\n", remoteHost, iFromPort);
+         return OO_OK;
+      }
+   }
+
+   if(ASN_OK != setPERBuffer (pctxt, recvBuf, recvLen, TRUE ) )
+   {
+      OOTRACEERR1("Error:Failed to set PER buffer for RAS message decoding\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }      
+   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
+   if(!pRasMsg)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for RAS message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+#ifndef _COMPACT
+   initializePrintHandler(&printHandler, "Received RAS Message");
+   /* Add event handler to list */
+   setEventHandler (pctxt, &printHandler);
+#endif
+   if(ASN_OK == asn1PD_H225RasMessage(pctxt, pRasMsg))
+   {
+#ifndef _COMPACT
+      finishPrint();
+      removeEventHandler(pctxt);
+#endif
+      iRet=ooGkClientHandleRASMessage( pGkClient, pRasMsg );
+      if(iRet != OO_OK)
+      {
+         OOTRACEERR1("Error: Failed to handle received RAS message\n");
+         //pGkClient->state = GkClientFailed;
+      }
+      memReset(pctxt);
+   }
+   else{
+      OOTRACEERR1("ERROR:Failed to decode received RAS message- ignoring"
+                  "received message.\n");
+#ifndef _COMPACT
+      removeEventHandler(pctxt);
+#endif
+      memReset(pctxt);
+      return OO_FAILED;
+   }
+   return iRet;
+}
+
+
+
+
+/**
+ * Manage incoming RAS message.
+ */
+
+int ooGkClientHandleRASMessage(ooGkClient *pGkClient, H225RasMessage *pRasMsg)
+{
+   int iRet = OO_OK;   
+   switch( pRasMsg->t)
+   {
+   case T_H225RasMessage_gatekeeperConfirm:
+      OOTRACEINFO1("Gatekeeper Confirmed (GCF) message received.\n");
+      iRet = ooGkClientHandleGatekeeperConfirm(pGkClient, 
+                                          pRasMsg->u.gatekeeperConfirm);
+      break;
+   case T_H225RasMessage_gatekeeperReject: 
+      OOTRACEINFO1("Gatekeeper Reject (GRJ) message received\n");
+      iRet = ooGkClientHandleGatekeeperReject(pGkClient, 
+                                              pRasMsg->u.gatekeeperReject);
+      break;
+   case T_H225RasMessage_registrationConfirm:   
+      OOTRACEINFO1("Registration Confirm (RCF) message received\n");
+      iRet = ooGkClientHandleRegistrationConfirm(pGkClient,  
+                                              pRasMsg->u.registrationConfirm );
+      break;
+   case T_H225RasMessage_registrationReject:
+      OOTRACEINFO1("Registration Reject (RRJ) message received.\n");
+      iRet = ooGkClientHandleRegistrationReject(pGkClient, 
+                                                pRasMsg->u.registrationReject);
+      break;
+   case T_H225RasMessage_infoRequest:  
+      //ooRasSendIRR( psRasMsg->sMessage.u.infoRequest->requestSeqNum );
+      break;
+   case T_H225RasMessage_admissionConfirm:
+      OOTRACEINFO1("Admission Confirm (ACF) message received\n");
+      iRet = ooGkClientHandleAdmissionConfirm(pGkClient, 
+                                              pRasMsg->u.admissionConfirm);
+      break;
+   case T_H225RasMessage_unregistrationRequest:
+      OOTRACEINFO1("UnRegistration Request (URQ) message received.\n");
+      iRet = ooGkClientHandleUnregistrationRequest(pGkClient, 
+                                            pRasMsg->u.unregistrationRequest);
+      break;
+   case T_H225RasMessage_unregistrationConfirm:
+      OOTRACEINFO1("UnRegistration Confirm (UCF) message received.\n");
+      break;
+   case T_H225RasMessage_unregistrationReject:
+      OOTRACEINFO1("UnRegistration Reject (URJ) message received.\n");
+      break;
+   case T_H225RasMessage_admissionReject:
+      OOTRACEINFO1("Admission Reject (ARJ) message received.\n");
+      iRet = ooGkClientHandleAdmissionReject(pGkClient, 
+                                                   pRasMsg->u.admissionReject);
+      break;
+   case T_H225RasMessage_disengageConfirm:
+      iRet = ooGkClientHandleDisengageConfirm(pGkClient, 
+                                              pRasMsg->u.disengageConfirm);
+      break;
+   case T_H225RasMessage_disengageReject:
+   case T_H225RasMessage_bandwidthConfirm:
+   case T_H225RasMessage_bandwidthReject:
+   case T_H225RasMessage_locationRequest:
+   case T_H225RasMessage_locationConfirm:
+   case T_H225RasMessage_locationReject:
+   case T_H225RasMessage_infoRequestResponse:
+   case T_H225RasMessage_nonStandardMessage:
+   case T_H225RasMessage_unknownMessageResponse:
+   case T_H225RasMessage_requestInProgress:
+   case T_H225RasMessage_resourcesAvailableIndicate:
+   case T_H225RasMessage_resourcesAvailableConfirm:
+   case T_H225RasMessage_infoRequestAck:
+   case T_H225RasMessage_infoRequestNak:
+   case T_H225RasMessage_serviceControlIndication:
+   case T_H225RasMessage_serviceControlResponse:
+   case T_H225RasMessage_admissionConfirmSequence:
+   default:
+      /* Unhandled RAS message */
+      iRet= OO_OK;
+   }
+
+   return iRet;
+}
+
+#ifndef _COMPACT
+void ooGkClientPrintMessage
+   (ooGkClient *pGkClient, ASN1OCTET *msg, ASN1UINT len)
+{
+   OOCTXT ctxt;
+   H225RasMessage rasMsg;
+   int ret; 
+
+   initContext(&ctxt);
+   setPERBuffer(&ctxt, msg, len, TRUE);
+   initializePrintHandler(&printHandler, "Sending RAS Message");
+   setEventHandler(&ctxt, &printHandler);
+
+   ret = asn1PD_H225RasMessage(&ctxt, &rasMsg);
+   if(ret != ASN_OK)
+   {
+      OOTRACEERR1("Error: Failed to decode RAS message\n");
+   }
+   finishPrint();
+   freeContext(&ctxt);
+}
+#endif
+/**
+ * Encode and send RAS message.
+ */
+
+int ooGkClientSendMsg(ooGkClient *pGkClient, H225RasMessage *pRasMsg)
+{
+   ASN1OCTET msgBuf[MAXMSGLEN];
+   ASN1OCTET *msgPtr=NULL;
+   int  iLen;
+   OOCTXT *pctxt = &pGkClient->msgCtxt;
+
+   setPERBuffer( pctxt, msgBuf, MAXMSGLEN, TRUE );
+   if ( ASN_OK == asn1PE_H225RasMessage(pctxt, pRasMsg) )
+   {
+      OOTRACEDBGC1("Ras message encoding - successful\n");
+   }
+   else {
+      OOTRACEERR1("Error: RAS message encoding failed\n");
+      return OO_FAILED;
+   }
+
+   msgPtr = encodeGetMsgPtr( pctxt, &iLen );
+   /* If gatekeeper specified or have been discovered */
+   if(pGkClient->gkMode == RasUseSpecificGatekeeper || 
+      pGkClient->discoveryComplete)
+   {
+      if(ASN_OK != ooSocketSendTo( pGkClient->rasSocket, msgPtr, iLen, 
+                                   pGkClient->gkRasIP, pGkClient->gkRasPort))
+      {
+         OOTRACEERR1("Error sending RAS message\n");
+         return OO_FAILED;
+      }
+   }
+   else if(pGkClient->gkMode == RasDiscoverGatekeeper && 
+           !pGkClient->discoveryComplete) { 
+      if(ASN_OK != ooSocketSendTo(pGkClient->rasSocket, msgPtr, iLen, 
+                                       MULTICAST_GKADDRESS, MULTICAST_GKPORT))
+      {
+         OOTRACEERR1("Error sending multicast RAS message\n" );
+         return OO_FAILED;
+      }
+   }
+   else {/* should never go here */ 
+      OOTRACEERR1("Error: GkClient in invalid state.\n");
+      return OO_FAILED;
+   }
+#ifndef _COMPACT
+   ooGkClientPrintMessage(pGkClient, msgPtr, iLen);
+#endif
+   return OO_OK;
+}
+
+
+
+int ooGkClientSendGRQ(ooGkClient *pGkClient)
+{
+   int iRet;
+   H225RasMessage *pRasMsg=NULL;
+   H225GatekeeperRequest *pGkReq=NULL;
+   H225TransportAddress_ipAddress *pRasAddress;
+   OOCTXT *pctxt = &pGkClient->msgCtxt;
+   ooGkClientTimerCb *cbData=NULL;
+
+   
+
+   /* Allocate memory for RAS message */
+   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
+   if(!pRasMsg)
+   {
+      OOTRACEERR1("Error: Memory allocation for GRQ RAS message failed\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+
+   pGkReq = (H225GatekeeperRequest*)memAlloc(pctxt, 
+                                                sizeof(H225GatekeeperRequest));
+   if(!pGkReq)
+   {
+      OOTRACEERR1("Error:Memory allocation for GRQ failed\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memset(pGkReq, 0, sizeof(H225GatekeeperRequest));
+   pRasMsg->t = T_H225RasMessage_gatekeeperRequest;
+   pRasMsg->u.gatekeeperRequest = pGkReq;
+
+   /* Populate message structure */
+   pGkReq->requestSeqNum = pGkClient->requestSeqNum++;
+   if ( !pGkReq->requestSeqNum )
+      pGkReq->requestSeqNum = pGkClient->requestSeqNum++;
+
+   pGkReq->protocolIdentifier = gProtocolID;
+   pGkReq->m.nonStandardDataPresent=0;
+   pGkReq->rasAddress.t=T_H225TransportAddress_ipAddress; /* IPv4 address */
+   pRasAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt, 
+                                      sizeof(H225TransportAddress_ipAddress));
+   if(!pRasAddress)
+   {
+      OOTRACEERR1("Error: Memory allocation for Ras Address of GRQ message "
+                  "failed\n");
+      memReset(&pGkClient->msgCtxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+
+ 
+   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pRasAddress->ip.data);
+
+   pRasAddress->ip.numocts = 4;
+   pRasAddress->port = pGkClient->localRASPort;
+   pGkReq->rasAddress.u.ipAddress = pRasAddress;
+
+   /* Pose as gateway or terminal as per config */
+   if(gH323ep.isGateway)
+      pGkReq->endpointType.m.gatewayPresent = TRUE;
+   else
+      pGkReq->endpointType.m.terminalPresent = TRUE;
+
+   pGkReq->endpointType.m.nonStandardDataPresent=0;
+   pGkReq->endpointType.m.vendorPresent=1;
+
+   ooGkClientFillVendor(pGkClient, &pGkReq->endpointType.vendor);
+
+
+   pGkReq->m.endpointAliasPresent=TRUE;
+   if(OO_OK != ooPopulateAliasList(&pGkClient->msgCtxt, gH323ep.aliases, 
+                                      &pGkReq->endpointAlias))
+   {
+      OOTRACEERR1("Error Failed to fill alias information for GRQ message\n");
+      memReset(&pGkClient->msgCtxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error: Failed to send GRQ message\n");
+      memReset(&pGkClient->msgCtxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   OOTRACEINFO1("Sent GRQ message\n");
+   cbData = (ooGkClientTimerCb*) memAlloc
+                               (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
+   if(!cbData)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory to GRQ timer callback\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   cbData->timerType = OO_GRQ_TIMER;
+   cbData->pGkClient = pGkClient;
+   if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, 
+                     &ooGkClientGRQTimerExpired, pGkClient->grqTimeout, 
+                     cbData, FALSE))      
+   {
+      OOTRACEERR1("Error:Unable to create GRQ timer.\n ");
+      memFreePtr(&pGkClient->ctxt, cbData);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   return OO_OK;
+}
+
+int ooGkClientHandleGatekeeperReject
+   (ooGkClient *pGkClient, H225GatekeeperReject *pGatekeeperReject)
+{
+   unsigned int x=0;
+   DListNode *pNode = NULL;
+   OOTimer *pTimer = NULL;
+
+   if(pGkClient->gkMode == RasUseSpecificGatekeeper)
+   {
+      /* delete the corresponding GRQ timer */
+      for(x=0; x<pGkClient->timerList.count; x++)
+      {
+         pNode =  dListFindByIndex(&pGkClient->timerList, x);
+         pTimer = (OOTimer*)pNode->data;
+         if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_GRQ_TIMER)
+         {
+            memFreePtr(&pGkClient->ctxt, pTimer->cbData);
+            ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer);
+            OOTRACEDBGA1("Deleted GRQ Timer.\n");
+            break;
+         }
+      }
+ 
+      pGkClient->state = GkClientGkErr;
+      switch(pGatekeeperReject->rejectReason.t)
+      {
+      case T_H225GatekeeperRejectReason_resourceUnavailable:
+         OOTRACEERR1("Error: Gatekeeper Reject - Resource Unavailable\n");
+         break;
+      case T_H225GatekeeperRejectReason_terminalExcluded:
+         OOTRACEERR1("Error: Gatekeeper Reject - Terminal Excluded\n");
+         break;
+      case T_H225GatekeeperRejectReason_invalidRevision:
+         OOTRACEERR1("Error: Gatekeeper Reject - Invalid Revision\n");
+         break;
+      case T_H225GatekeeperRejectReason_undefinedReason:
+         OOTRACEERR1("Error: Gatekeeper Reject - Undefined Reason\n");
+         break;
+      case T_H225GatekeeperRejectReason_securityDenial:
+         OOTRACEERR1("Error: Gatekeeper Reject - Security Denial\n");
+         break;
+      case T_H225GatekeeperRejectReason_genericDataReason:
+         OOTRACEERR1("Error: Gatekeeper Reject - Generic Data Reason\n");
+         break;
+      case T_H225GatekeeperRejectReason_neededFeatureNotSupported:
+         OOTRACEERR1("Error: Gatekeeper Reject - Needed Feature Not "
+                     "Supported\n");
+         break;
+      case T_H225GatekeeperRejectReason_securityError:
+         OOTRACEERR1("Error:Gatekeeper Reject - Security Error\n");
+         break;
+      default:
+         OOTRACEERR1("Error: Gatekeeper Reject - Invalid reason\n");
+      }
+      return OO_OK;
+   }
+   OOTRACEDBGB1("Gatekeeper Reject response received for multicast GRQ "
+                "request\n");
+   return OO_OK;
+
+}
+
+int ooGkClientHandleGatekeeperConfirm
+   (ooGkClient *pGkClient, H225GatekeeperConfirm *pGatekeeperConfirm)
+{
+   int iRet=0;
+   unsigned int x=0;
+   DListNode *pNode = NULL;
+   OOTimer *pTimer = NULL;
+   H225TransportAddress_ipAddress *pRasAddress;
+
+   if(pGkClient->discoveryComplete)
+   {
+      OOTRACEDBGB1("Ignoring GKConfirm as Gatekeeper has been discovered\n");
+      return OO_OK;
+   }
+
+   if(pGatekeeperConfirm->m.gatekeeperIdentifierPresent) 
+   {
+      pGkClient->gkId.nchars = pGatekeeperConfirm->gatekeeperIdentifier.nchars;
+      pGkClient->gkId.data = (ASN116BITCHAR*)memAlloc(&pGkClient->ctxt,
+                              sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars);
+      if(!pGkClient->gkId.data)
+      {
+         OOTRACEERR1("Error:Failed to allocate memory for GK ID data\n");
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      }
+
+      memcpy(pGkClient->gkId.data, 
+             pGatekeeperConfirm->gatekeeperIdentifier.data,
+             sizeof(ASN116BITCHAR)* pGkClient->gkId.nchars);
+   }
+   else{
+      OOTRACEERR1("ERROR:No Gatekeeper ID present in received GKConfirmed "
+                  "message\n");
+      OOTRACEINFO1("Ignoring message and will retransmit GRQ after timeout\n");
+      return OO_FAILED;
+   }
+   
+   /* Extract Gatekeeper's RAS address */
+   if(pGatekeeperConfirm->rasAddress.t != T_H225TransportAddress_ipAddress)
+   {
+      OOTRACEERR1("ERROR:Unsupported RAS address type in received Gk Confirm"
+                  " message.\n");
+      pGkClient->state = GkClientGkErr;
+      return OO_FAILED;
+   }
+   pRasAddress =   pGatekeeperConfirm->rasAddress.u.ipAddress;
+   sprintf(pGkClient->gkRasIP, "%d.%d.%d.%d", pRasAddress->ip.data[0],
+                                              pRasAddress->ip.data[1],
+                                              pRasAddress->ip.data[2], 
+                                              pRasAddress->ip.data[3]);
+   pGkClient->gkRasPort = pRasAddress->port;
+   
+   pGkClient->discoveryComplete = TRUE;
+   pGkClient->state = GkClientDiscovered;
+   OOTRACEINFO1("Gatekeeper Confirmed\n");
+
+
+   /* Delete the corresponding GRQ timer */
+   for(x=0; x<pGkClient->timerList.count; x++)
+   {
+      pNode =  dListFindByIndex(&pGkClient->timerList, x);
+      pTimer = (OOTimer*)pNode->data;
+      if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_GRQ_TIMER)
+      {
+         memFreePtr(&pGkClient->ctxt, pTimer->cbData);
+         ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer);
+         OOTRACEDBGA1("Deleted GRQ Timer.\n");
+         break;
+      }
+   }
+
+   iRet = ooGkClientSendRRQ(pGkClient, FALSE);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error:Failed to send initial RRQ\n");
+      return OO_FAILED;
+   }
+   return OO_OK;
+}
+
+/**
+ * Send RRQ.
+ */
+
+int ooGkClientSendRRQ(ooGkClient *pGkClient, ASN1BOOL keepAlive)
+{
+   int iRet;
+   H225RasMessage *pRasMsg=NULL;
+   H225RegistrationRequest *pRegReq=NULL;
+   OOCTXT *pctxt=NULL;
+   H225TransportAddress *pTransportAddress=NULL;
+   H225TransportAddress_ipAddress *pIpAddress=NULL;
+   ooGkClientTimerCb *cbData =NULL;
+
+   pctxt = &pGkClient->msgCtxt;
+
+   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
+   if(!pRasMsg)
+   {
+      OOTRACEERR1("Error: Memory allocation for RRQ RAS message failed\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+
+   pRegReq = (H225RegistrationRequest*)memAlloc(pctxt, 
+                                          sizeof(H225RegistrationRequest));
+   if(!pRegReq)
+   {
+      OOTRACEERR1("Error:Memory allocation for RRQ failed\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memset(pRegReq, 0, sizeof(H225RegistrationRequest));
+   pRasMsg->t = T_H225RasMessage_registrationRequest;
+   pRasMsg->u.registrationRequest = pRegReq;
+   
+   pRegReq->protocolIdentifier = gProtocolID;
+   pRegReq->m.nonStandardDataPresent=0;
+   /* Populate CallSignal Address List*/
+   pTransportAddress = (H225TransportAddress*) memAlloc(pctxt, 
+                                                 sizeof(H225TransportAddress));
+   pIpAddress = (H225TransportAddress_ipAddress*) memAlloc(pctxt,
+                                       sizeof(H225TransportAddress_ipAddress));
+   if(!pTransportAddress || !pIpAddress)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for signalling address of "
+                  "RRQ message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   pTransportAddress->t = T_H225TransportAddress_ipAddress;
+   pTransportAddress->u.ipAddress = pIpAddress;
+   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddress->ip.data);
+   pIpAddress->ip.numocts = 4;
+   pIpAddress->port = gH323ep.listenPort;
+   
+   dListInit(&pRegReq->callSignalAddress);
+   dListAppend(pctxt, &pRegReq->callSignalAddress, 
+                                       (void*)pTransportAddress);
+
+   /* Populate RAS Address List*/
+   pTransportAddress = NULL;
+   pIpAddress = NULL;
+   pTransportAddress = (H225TransportAddress*) memAlloc(pctxt, 
+                                                 sizeof(H225TransportAddress));
+   pIpAddress = (H225TransportAddress_ipAddress*) memAlloc(pctxt,
+                                       sizeof(H225TransportAddress_ipAddress));
+   if(!pTransportAddress || !pIpAddress)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for RAS address of "
+                  "RRQ message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+
+   pTransportAddress->t = T_H225TransportAddress_ipAddress;
+   pTransportAddress->u.ipAddress = pIpAddress;
+   
+   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddress->ip.data);
+
+   pIpAddress->ip.numocts = 4;
+   pIpAddress->port = pGkClient->localRASPort;
+   
+   dListInit(&pRegReq->rasAddress);
+   dListAppend(pctxt, &pRegReq->rasAddress, 
+                                       (void*)pTransportAddress);
+   
+   /* Pose as gateway or terminal as per config */
+   if(gH323ep.isGateway)
+      pRegReq->terminalType.m.gatewayPresent = TRUE;
+   else
+      pRegReq->terminalType.m.terminalPresent = TRUE;
+
+   pRegReq->terminalType.m.vendorPresent=TRUE;
+   ooGkClientFillVendor(pGkClient, &pRegReq->terminalType.vendor );
+  
+   pRegReq->m.terminalAliasPresent=TRUE;
+   if(OO_OK != ooPopulateAliasList(pctxt, gH323ep.aliases, 
+                                      &pRegReq->terminalAlias))
+   {
+      OOTRACEERR1("Error filling alias for RRQ\n");
+      memReset(pctxt); 
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   
+   pRegReq->m.gatekeeperIdentifierPresent=TRUE;
+   pRegReq->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars;
+   pRegReq->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc
+                         (pctxt, pGkClient->gkId.nchars*sizeof(ASN116BITCHAR));
+   if(!pRegReq->gatekeeperIdentifier.data)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for GKIdentifier in RRQ "
+                   "message.\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memcpy(pRegReq->gatekeeperIdentifier.data, pGkClient->gkId.data, 
+                                pGkClient->gkId.nchars*sizeof(ASN116BITCHAR));
+   
+   ooGkClientFillVendor(pGkClient, &pRegReq->endpointVendor);
+   
+   pRegReq->m.willSupplyUUIEsPresent=TRUE;
+   pRegReq->willSupplyUUIEs=FALSE;
+
+   pRegReq->requestSeqNum = pGkClient->requestSeqNum++;
+   if(!pRegReq->requestSeqNum)
+      pRegReq->requestSeqNum = pGkClient->requestSeqNum++;
+   
+   pRegReq->discoveryComplete= pGkClient->discoveryComplete;
+   pRegReq->m.keepAlivePresent=TRUE;
+   pRegReq->keepAlive= keepAlive;
+
+   /*
+    * Cisco Gatekeeper re-registration fix.  Thanks to Mike Tubby (mike@tubby.org) 28feb2007
+    * Without this patch initial registration works, but re-registration fails!
+    *
+    * For light-weight re-registration, keepalive is set true
+    * GK needs rasAddress, keepAlive, endpointIdentifier, gatekeeperIdentifier,
+    * tokens, and timeToLive
+    * GK will ignore all other params if KeepAlive is set.
+    *
+    */
+   if(keepAlive) {
+      /* KeepAlive, re-registration message...
+         allocate storage for endpoint-identifier, and populate it from what the
+         GK told us from the previous RCF. Only allocate on the first pass thru here */
+      pRegReq->endpointIdentifier.data = 
+           (ASN116BITCHAR*)memAlloc(pctxt, pGkClient->gkId.nchars*sizeof(ASN116BITCHAR));
+      if (pRegReq->endpointIdentifier.data) {
+         pRegReq->endpointIdentifier.nchars = pGkClient->endpointId.nchars;
+         pRegReq->m.endpointIdentifierPresent = TRUE;
+         memcpy(pRegReq->endpointIdentifier.data, pGkClient->endpointId.data, pGkClient->endpointId.nchars*sizeof(ASN116BITCHAR));
+         OOTRACEINFO1("Sending RRQ for re-registration (with EndpointID)\n");
+      }
+      else {
+         OOTRACEERR1("Error: Failed to allocate memory for EndpointIdentifier in RRQ \n");
+         memReset(pctxt);
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      }
+   }
+
+   pRegReq->m.timeToLivePresent = TRUE;
+   pRegReq->timeToLive = pGkClient->regTimeout;
+
+   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error: Failed to send RRQ message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   OOTRACEINFO1("Sent RRQ message \n");
+   /* Start RRQ Timer */
+   cbData = (ooGkClientTimerCb*) memAlloc
+                            (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
+   if(!cbData)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory to RRQ timer callback\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   cbData->timerType = OO_RRQ_TIMER;
+   cbData->pGkClient = pGkClient;
+   if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, 
+                     &ooGkClientRRQTimerExpired, pGkClient->rrqTimeout, 
+                     cbData, FALSE))      
+   {
+      OOTRACEERR1("Error:Unable to create GRQ timer.\n ");
+      memFreePtr(&pGkClient->ctxt, cbData);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   
+   return OO_OK;
+}
+
+
+
+/**
+ * Manage incoming RCF message.
+ */
+
+int ooGkClientHandleRegistrationConfirm
+   (ooGkClient *pGkClient, H225RegistrationConfirm *pRegistrationConfirm)
+{
+   int i=0;
+   unsigned int x=0;
+   OOTimer *pTimer = NULL;
+   DListNode *pNode = NULL;
+   H225TransportAddress *pCallSigAddr=NULL;
+   ooGkClientTimerCb *cbData;
+   ASN1UINT regTTL=0;
+   /* Extract Endpoint Id */
+   pGkClient->endpointId.nchars = 
+                              pRegistrationConfirm->endpointIdentifier.nchars;
+   pGkClient->endpointId.data = (ASN116BITCHAR*)memAlloc(&pGkClient->ctxt,
+                          sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
+   if(!pGkClient->endpointId.data)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for endpoint Id.\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   
+   memcpy(pGkClient->endpointId.data, 
+          pRegistrationConfirm->endpointIdentifier.data,
+          sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
+   
+   /* Extract CallSignalling Address */
+   for(i=0; i<(int)pRegistrationConfirm->callSignalAddress.count; i++)
+   {
+      pNode = dListFindByIndex(&pRegistrationConfirm->callSignalAddress, i);
+      if(!pNode)
+      {
+         OOTRACEERR1("Error:Invalid Registration confirmed message\n");
+         OOTRACEINFO1("Ignoring RCF, will retransmit RRQ after timeout\n");
+         return OO_FAILED; 
+      }
+      pCallSigAddr = (H225TransportAddress*)pNode->data;
+      if(pCallSigAddr->t != T_H225TransportAddress_ipAddress)
+         continue;
+      sprintf(pGkClient->gkCallSignallingIP, "%d.%d.%d.%d", 
+                            pCallSigAddr->u.ipAddress->ip.data[0],
+                            pCallSigAddr->u.ipAddress->ip.data[1],
+                            pCallSigAddr->u.ipAddress->ip.data[2],
+                            pCallSigAddr->u.ipAddress->ip.data[3]);
+      pGkClient->gkCallSignallingPort = pCallSigAddr->u.ipAddress->port;
+   }
+   
+   /* Update list of registered aliases*/
+   if(pRegistrationConfirm->m.terminalAliasPresent)
+   {
+      ooGkClientUpdateRegisteredAliases(pGkClient, 
+                                   &pRegistrationConfirm->terminalAlias, TRUE);
+   }
+   else{/* Everything registered*/
+     ooGkClientUpdateRegisteredAliases(pGkClient, NULL, TRUE);
+   }
+
+   /* Is keepAlive supported */
+   if(pRegistrationConfirm->m.timeToLivePresent)
+   {
+      pGkClient->regTimeout = pRegistrationConfirm->timeToLive;
+      OOTRACEINFO2("Gatekeeper supports KeepAlive, Registration TTL is %d\n",
+                    pRegistrationConfirm->timeToLive);
+
+      if(pGkClient->regTimeout > DEFAULT_TTL_OFFSET)
+         regTTL = pGkClient->regTimeout - DEFAULT_TTL_OFFSET;
+      else
+         regTTL = pGkClient->regTimeout;
+
+      cbData = (ooGkClientTimerCb*) memAlloc
+                                (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
+      if(!cbData)
+      {
+         OOTRACEERR1("Error:Failed to allocate memory for Regisration timer."
+                     "\n");
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      }
+      cbData->timerType = OO_REG_TIMER;
+      cbData->pGkClient = pGkClient;
+      if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, 
+                     &ooGkClientREGTimerExpired, regTTL, 
+                     cbData, FALSE))
+      {
+         OOTRACEERR1("Error:Unable to create REG timer.\n ");
+         memFreePtr(&pGkClient->ctxt, cbData);
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      }    
+      
+   }
+   else{
+      pGkClient->regTimeout = 0;
+      OOTRACEINFO1("Gatekeeper does not support KeepAlive.\n");
+   }
+   /* Extract Pre-Granted ARQ */
+   if(pRegistrationConfirm->m.preGrantedARQPresent)
+   {
+      memcpy(&pGkClient->gkInfo.preGrantedARQ, 
+             &pRegistrationConfirm->preGrantedARQ,
+             sizeof(H225RegistrationConfirm_preGrantedARQ));
+   }
+
+
+   /* First delete the corresponding RRQ timer */
+   pNode = NULL;
+   for(x=0; x<pGkClient->timerList.count; x++)
+   {
+      pNode =  dListFindByIndex(&pGkClient->timerList, x);
+      pTimer = (OOTimer*)pNode->data;
+      if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_RRQ_TIMER)
+      {
+         memFreePtr(&pGkClient->ctxt, pTimer->cbData);
+         ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer);
+         OOTRACEDBGA1("Deleted RRQ Timer.\n");
+         break;
+      }
+   }
+   pGkClient->state = GkClientRegistered;
+   if(pGkClient->callbacks.onReceivedRegistrationConfirm)
+      pGkClient->callbacks.onReceivedRegistrationConfirm(pRegistrationConfirm,
+                                                              gH323ep.aliases);
+   return OO_OK;
+}
+
+int ooGkClientHandleRegistrationReject
+   (ooGkClient *pGkClient, H225RegistrationReject *pRegistrationReject)
+{
+   int iRet=0;
+   unsigned int x=0;
+   DListNode *pNode = NULL;
+   OOTimer *pTimer = NULL;
+   /* First delete the corresponding RRQ timer */
+   for(x=0; x<pGkClient->timerList.count; x++)
+   {
+      pNode =  dListFindByIndex(&pGkClient->timerList, x);
+      pTimer = (OOTimer*)pNode->data;
+      if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_RRQ_TIMER)
+      {
+         memFreePtr(&pGkClient->ctxt, pTimer->cbData);
+         ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer);
+         OOTRACEDBGA1("Deleted RRQ Timer.\n");
+         break;
+      }
+   }
+
+   switch(pRegistrationReject->rejectReason.t)
+   {
+   case T_H225RegistrationRejectReason_discoveryRequired:
+      OOTRACEINFO1("RRQ Rejected - Discovery Required\n");
+
+      pGkClient->discoveryComplete = FALSE;
+      pGkClient->state = GkClientIdle;
+      pGkClient->rrqRetries = 0;
+      pGkClient->grqRetries = 0;
+      if(OO_OK != ooGkClientSendGRQ(pGkClient))
+      {
+         OOTRACEERR1("Error:Failed to send GRQ message\n");
+         return OO_FAILED;
+      }
+      return OO_OK;
+   case T_H225RegistrationRejectReason_invalidRevision:
+      OOTRACEERR1("RRQ Rejected - Invalid Revision\n");
+      break;
+   case T_H225RegistrationRejectReason_invalidCallSignalAddress:
+      OOTRACEERR1("RRQ Rejected - Invalid CallSignalAddress\n");
+      break;
+   case T_H225RegistrationRejectReason_invalidRASAddress:
+      OOTRACEERR1("RRQ Rejected - Invalid RAS Address\n");
+      break;
+   case T_H225RegistrationRejectReason_duplicateAlias:
+      OOTRACEERR1("RRQ Rejected - Duplicate Alias\n");
+      break;
+   case T_H225RegistrationRejectReason_invalidTerminalType:
+      OOTRACEERR1("RRQ Rejected - Invalid Terminal Type\n");
+      break;
+   case T_H225RegistrationRejectReason_undefinedReason:
+      OOTRACEERR1("RRQ Rejected - Undefined Reason\n");
+      break;
+   case T_H225RegistrationRejectReason_transportNotSupported:
+      OOTRACEERR1("RRQ Rejected - Transport Not supported\n");
+      break;
+   case T_H225RegistrationRejectReason_transportQOSNotSupported:
+      OOTRACEERR1("RRQ Rejected - Transport QOS Not Supported\n");
+      break;
+   case T_H225RegistrationRejectReason_resourceUnavailable:
+      OOTRACEERR1("RRQ Rejected - Resource Unavailable\n");
+      break;
+   case T_H225RegistrationRejectReason_invalidAlias:
+      OOTRACEERR1("RRQ Rejected - Invalid Alias\n");
+      break;
+   case T_H225RegistrationRejectReason_securityDenial:
+      OOTRACEERR1("RRQ Rejected - Security Denial\n");
+      break;
+   case T_H225RegistrationRejectReason_fullRegistrationRequired:
+      OOTRACEINFO1("RRQ Rejected - Full Registration Required\n");
+      pGkClient->state = GkClientDiscovered;
+      pGkClient->rrqRetries = 0;
+      iRet = ooGkClientSendRRQ(pGkClient, 0); /* No keepAlive */
+      if(iRet != OO_OK){
+         OOTRACEERR1("\nError: Full Registration transmission failed\n");
+         return OO_FAILED;
+      }
+      return OO_OK;
+   case T_H225RegistrationRejectReason_additiveRegistrationNotSupported:
+      OOTRACEERR1("RRQ Rejected - Additive Registration Not Supported\n");
+      break;
+   case T_H225RegistrationRejectReason_invalidTerminalAliases:
+      OOTRACEERR1("RRQ Rejected - Invalid Terminal Aliases\n");
+      break;
+   case T_H225RegistrationRejectReason_genericDataReason:
+      OOTRACEERR1("RRQ Rejected - Generic Data Reason\n");
+      break;
+   case T_H225RegistrationRejectReason_neededFeatureNotSupported:
+      OOTRACEERR1("RRQ Rejected - Needed Feature Not Supported\n");
+      break;
+   case T_H225RegistrationRejectReason_securityError:
+      OOTRACEERR1("RRQ Rejected - Security Error\n");
+      break;
+   default:
+      OOTRACEINFO1("RRQ Rejected - Invalid Reason\n");
+   }
+   pGkClient->state = GkClientGkErr;
+   return OO_OK;
+}
+
+
+int ooGkClientSendURQ(ooGkClient *pGkClient, ooAliases *aliases)
+{
+   int iRet;
+   H225RasMessage *pRasMsg=NULL;
+   H225UnregistrationRequest *pUnregReq=NULL;
+   OOCTXT *pctxt=NULL;
+   H225TransportAddress *pTransportAddress=NULL;
+   H225TransportAddress_ipAddress *pIpAddress=NULL;
+
+   pctxt = &pGkClient->msgCtxt;
+
+   OOTRACEDBGA1("Building Unregistration Request message\n");
+
+   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
+   if(!pRasMsg)
+   {
+      OOTRACEERR1("Error: Memory allocation for URQ RAS message failed\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+
+   pUnregReq = (H225UnregistrationRequest*)memAlloc(pctxt, 
+                                          sizeof(H225UnregistrationRequest));
+   if(!pUnregReq)
+   {
+      OOTRACEERR1("Error:Memory allocation for URQ failed\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memset(pUnregReq, 0, sizeof(H225UnregistrationRequest));
+   pRasMsg->t = T_H225RasMessage_unregistrationRequest;
+   pRasMsg->u.unregistrationRequest = pUnregReq;
+
+   pUnregReq->requestSeqNum = pGkClient->requestSeqNum++;
+   if(!pUnregReq->requestSeqNum)
+      pUnregReq->requestSeqNum = pGkClient->requestSeqNum++;
+
+   
+
+ /* Populate CallSignal Address List*/
+   pTransportAddress = (H225TransportAddress*) memAlloc(pctxt, 
+                                                 sizeof(H225TransportAddress));
+   pIpAddress = (H225TransportAddress_ipAddress*) memAlloc(pctxt,
+                                       sizeof(H225TransportAddress_ipAddress));
+   if(!pTransportAddress || !pIpAddress)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for signalling address of "
+                  "RRQ message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   pTransportAddress->t = T_H225TransportAddress_ipAddress;
+   pTransportAddress->u.ipAddress = pIpAddress;
+   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddress->ip.data);
+   pIpAddress->ip.numocts = 4;
+   pIpAddress->port = gH323ep.listenPort;
+   
+   dListInit(&pUnregReq->callSignalAddress);
+   dListAppend(pctxt, &pUnregReq->callSignalAddress, 
+                                       (void*)pTransportAddress);
+
+   /* Populate Endpoint Identifier */
+   pUnregReq->m.endpointIdentifierPresent = TRUE;
+   pUnregReq->endpointIdentifier.nchars = pGkClient->endpointId.nchars;
+   pUnregReq->endpointIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt,
+                           sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
+   if(!pUnregReq->endpointIdentifier.data)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for EndPoint Id in URQ "
+                  "message.\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memcpy((void*)pUnregReq->endpointIdentifier.data, 
+          (void*)pGkClient->endpointId.data,
+          sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
+
+   /* Populate gatekeeper identifier */
+   pUnregReq->m.gatekeeperIdentifierPresent = TRUE;
+   pUnregReq->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars;
+   pUnregReq->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt,
+                                 sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars);
+   if(!pUnregReq->gatekeeperIdentifier.data)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for GKID of URQ message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memcpy((void*)pUnregReq->gatekeeperIdentifier.data, 
+          (void*)pGkClient->gkId.data, 
+          sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars);   
+
+   /* Check whether specific aliases are to be unregistered*/
+   if(aliases)
+   {
+      pUnregReq->m.endpointAliasPresent = TRUE;
+      ooPopulateAliasList(pctxt, aliases, &pUnregReq->endpointAlias);
+   }
+
+  
+   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error:Failed to send UnregistrationRequest message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   pGkClient->state = GkClientUnregistered;
+   OOTRACEINFO1("Unregistration Request message sent.\n");
+
+   return OO_OK;
+}               
+
+
+
+int ooGkClientHandleUnregistrationRequest
+   (ooGkClient *pGkClient, H225UnregistrationRequest * punregistrationRequest)
+{
+   int iRet=0;
+
+   /* Lets first send unregistration confirm message back to gatekeeper*/
+   ooGkClientSendUnregistrationConfirm(pGkClient, 
+                                      punregistrationRequest->requestSeqNum);
+
+   if(punregistrationRequest->m.endpointAliasPresent)
+   {
+      OOTRACEINFO1("Gatekeeper requested a list of aliases be unregistered\n");
+      ooGkClientUpdateRegisteredAliases(pGkClient, 
+                                &punregistrationRequest->endpointAlias, FALSE);
+   }
+   else{
+
+      OOTRACEINFO1("Gatekeeper requested a all aliases to be unregistered\n");
+      ooGkClientUpdateRegisteredAliases(pGkClient, NULL, FALSE);
+      /* Send a fresh Registration request and if that fails, go back to
+         Gatekeeper discovery.
+      */
+      OOTRACEINFO1("Sending fresh RRQ - as unregistration request received\n");
+      pGkClient->rrqRetries = 0;
+      pGkClient->state = GkClientDiscovered;
+
+      iRet = ooGkClientSendRRQ(pGkClient, 0); 
+      if(iRet != OO_OK)
+      {
+         OOTRACEERR1("Error: Failed to send RRQ message\n");
+         return OO_FAILED;
+      }
+   }
+
+
+   if(pGkClient->callbacks.onReceivedUnregistrationRequest)
+      pGkClient->callbacks.onReceivedUnregistrationRequest(
+                                      punregistrationRequest, gH323ep.aliases);
+   return OO_OK;
+}
+
+int ooGkClientSendUnregistrationConfirm(ooGkClient *pGkClient, unsigned reqNo)
+{
+   int iRet = OO_OK;
+   OOCTXT *pctxt = &pGkClient->msgCtxt;   
+   H225RasMessage *pRasMsg=NULL;
+   H225UnregistrationConfirm *pUCF=NULL;
+
+   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
+   pUCF = (H225UnregistrationConfirm*)memAlloc(pctxt, 
+                                           sizeof(H225UnregistrationConfirm));
+   if(!pRasMsg || !pUCF)
+   {
+      OOTRACEERR1("Error: Memory allocation for UCF RAS message failed\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   pRasMsg->t = T_H225RasMessage_unregistrationConfirm;
+   pRasMsg->u.unregistrationConfirm = pUCF;
+   memset(pUCF, 0, sizeof(H225UnregistrationConfirm));
+   
+   pUCF->requestSeqNum = reqNo;
+   
+   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error:Failed to send UnregistrationConfirm message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   OOTRACEINFO1("Unregistration Confirm message sent for \n");
+   memReset(pctxt);
+
+   return OO_OK;
+}
+
+
+
+
+int ooGkClientSendAdmissionRequest
+   (ooGkClient *pGkClient, OOH323CallData *call, ASN1BOOL retransmit)
+{
+   int iRet = 0;
+   unsigned int x;
+   DListNode *pNode;
+   ooGkClientTimerCb *cbData=NULL;
+   H225RasMessage *pRasMsg=NULL;
+   OOCTXT* pctxt;
+   H225AdmissionRequest *pAdmReq=NULL;
+   H225TransportAddress_ipAddress *pIpAddressLocal =NULL, *pIpAddressRemote=NULL;
+   ooAliases *destAliases = NULL, *srcAliases=NULL;
+   RasCallAdmissionInfo *pCallAdmInfo=NULL;
+   pctxt = &pGkClient->msgCtxt;
+
+   OOTRACEDBGA3("Building Admission Request for call (%s, %s)\n", 
+                 call->callType, call->callToken);   
+   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
+   if(!pRasMsg)
+   {
+      OOTRACEERR3("Error:Memory - ooGkClientSendAdmissionRequest - "
+                  "pRasMsg(%s, %s)\n", call->callType, call->callToken);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   pRasMsg->t = T_H225RasMessage_admissionRequest;
+   pAdmReq = (H225AdmissionRequest*) memAlloc(pctxt, 
+                                                 sizeof(H225AdmissionRequest));
+   if(!pAdmReq)
+   {
+      OOTRACEERR3("Error:Memory - ooGkClientSendAdmissionRequest - "
+                  "pAdmReq(%s, %s)\n", call->callType, call->callToken);
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memset(pAdmReq, 0, sizeof(H225AdmissionRequest));
+   pRasMsg->u.admissionRequest = pAdmReq;
+   
+   /* Populate call signalling addresses */
+   pIpAddressLocal = (H225TransportAddress_ipAddress*)memAlloc(pctxt, 
+                                     sizeof(H225TransportAddress_ipAddress));
+   if(!ooUtilsIsStrEmpty(call->remoteIP))
+      pIpAddressRemote = (H225TransportAddress_ipAddress*)memAlloc(pctxt, 
+                                      sizeof(H225TransportAddress_ipAddress));
+
+   if(!pIpAddressLocal || (!ooUtilsIsStrEmpty(call->remoteIP) && (!pIpAddressRemote)))
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for Call Signalling "
+                  "Addresses of ARQ message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddressLocal->ip.data);
+
+   pIpAddressLocal->ip.numocts = 4;
+   pIpAddressLocal->port = gH323ep.listenPort;
+
+   if(!ooUtilsIsStrEmpty(call->remoteIP))
+   {
+      ooSocketConvertIpToNwAddr(call->remoteIP, pIpAddressRemote->ip.data);
+      pIpAddressRemote->ip.numocts = 4;
+      pIpAddressRemote->port = call->remotePort;
+   }
+
+   if(!strcmp(call->callType, "incoming"))
+   {
+      pAdmReq->m.destCallSignalAddressPresent = TRUE;
+      pAdmReq->destCallSignalAddress.t = T_H225TransportAddress_ipAddress;
+      pAdmReq->destCallSignalAddress.u.ipAddress = pIpAddressLocal;
+      if(!ooUtilsIsStrEmpty(call->remoteIP))
+      {
+         pAdmReq->m.srcCallSignalAddressPresent = TRUE;
+         pAdmReq->srcCallSignalAddress.t = T_H225TransportAddress_ipAddress;
+         pAdmReq->srcCallSignalAddress.u.ipAddress = pIpAddressRemote;
+      }
+   }
+   else {
+      pAdmReq->m.srcCallSignalAddressPresent = TRUE;
+      pAdmReq->srcCallSignalAddress.t = T_H225TransportAddress_ipAddress;
+      pAdmReq->srcCallSignalAddress.u.ipAddress = pIpAddressLocal;
+      if(!ooUtilsIsStrEmpty(call->remoteIP))
+      {
+         pAdmReq->m.destCallSignalAddressPresent = TRUE;
+         pAdmReq->destCallSignalAddress.t = T_H225TransportAddress_ipAddress;
+         pAdmReq->destCallSignalAddress.u.ipAddress = pIpAddressRemote;
+      }
+   }
+
+   /* Populate seq number */
+   pAdmReq->requestSeqNum = pGkClient->requestSeqNum++;
+   if(!pAdmReq->requestSeqNum)
+      pAdmReq->requestSeqNum = pGkClient->requestSeqNum++;
+
+   /* Populate call type - For now only PointToPoint supported*/
+   pAdmReq->callType.t = T_H225CallType_pointToPoint;
+   
+   /* Add call model to message*/
+   pAdmReq->m.callModelPresent = 1;
+   if(OO_TESTFLAG(call->flags, OO_M_GKROUTED))
+      pAdmReq->callModel.t = T_H225CallModel_gatekeeperRouted;
+   else
+      pAdmReq->callModel.t = T_H225CallModel_direct;
+
+   /* Populate Endpoint Identifier */
+   pAdmReq->endpointIdentifier.nchars = pGkClient->endpointId.nchars;
+   pAdmReq->endpointIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt,
+                           sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
+   if(!pAdmReq->endpointIdentifier.data)
+   {
+      OOTRACEERR3("Error:Memory -  ooGkClientSendAdmissionRequest - "
+                  "endpointIdentifier.data(%s, %s)\n", call->callType, 
+                  call->callToken);
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memcpy((void*)pAdmReq->endpointIdentifier.data, 
+          (void*)pGkClient->endpointId.data,
+          sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
+
+   /* Get Destination And source aliases for call -  */
+   if(!strcmp(call->callType, "incoming"))
+   {
+      if(call->ourAliases) 
+         destAliases = call->ourAliases;
+      else
+         destAliases = gH323ep.aliases; 
+
+      srcAliases = call->remoteAliases;
+   }
+   else {
+      if(call->ourAliases) 
+         srcAliases = call->ourAliases;
+      else
+         srcAliases = gH323ep.aliases; 
+
+      destAliases = call->remoteAliases;
+   }
+
+   /* Populate destination info */
+   if(destAliases)
+   {
+      pAdmReq->m.destinationInfoPresent = 1;
+      if(OO_OK != ooPopulateAliasList(&pGkClient->msgCtxt, destAliases,
+                                      &pAdmReq->destinationInfo))
+      {
+         OOTRACEERR1("Error:Failed to populate destination aliases - "
+                    "ARQ message\n");
+         pGkClient->state = GkClientFailed;
+         memReset(pctxt);
+         return OO_FAILED;
+      }
+   }
+
+   /* Populate Source Info */
+   if(srcAliases)
+   {
+      iRet = ooPopulateAliasList(&pGkClient->msgCtxt, srcAliases,
+                                                          &pAdmReq->srcInfo);
+      if(OO_OK != iRet)
+      {
+         OOTRACEERR1("Error:Failed to populate source aliases -ARQ message\n");
+         memReset(pctxt);
+         pGkClient->state = GkClientFailed;      
+         return OO_FAILED;
+      }
+   }
+   
+   /* Populate bandwidth*/
+   pAdmReq->bandWidth = DEFAULT_BW_REQUEST;
+   /* Populate call Reference */
+   pAdmReq->callReferenceValue = call->callReference;
+   
+   /* populate conferenceID */
+   memcpy((void*)&pAdmReq->conferenceID, (void*)&call->confIdentifier,
+                                         sizeof(H225ConferenceIdentifier));
+   /*populate answerCall */
+   if(!strcmp(call->callType, "incoming"))
+      pAdmReq->answerCall = TRUE;
+   else
+      pAdmReq->answerCall = FALSE;
+
+   /* Populate CanMapAlias */
+   pAdmReq->m.canMapAliasPresent = TRUE;
+   pAdmReq->canMapAlias = FALSE;
+
+   /* Populate call identifier */
+   pAdmReq->m.callIdentifierPresent = TRUE;
+   memcpy((void*)&pAdmReq->callIdentifier, (void*)&call->callIdentifier,
+                                             sizeof(H225CallIdentifier));
+
+   /* Populate Gatekeeper Id */
+   pAdmReq->m.gatekeeperIdentifierPresent = TRUE;
+   pAdmReq->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars;
+   pAdmReq->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt,
+                                 sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars);
+   if(!pAdmReq->gatekeeperIdentifier.data)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for GKID of ARQ message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memcpy((void*)pAdmReq->gatekeeperIdentifier.data, 
+          (void*)pGkClient->gkId.data, 
+          sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars);
+
+   pAdmReq->m.willSupplyUUIEsPresent = 1;
+   pAdmReq->willSupplyUUIEs = FALSE;
+
+   /* Create RasCallAdmissionInfo */
+   if(!retransmit)
+   {
+      pCallAdmInfo = (RasCallAdmissionInfo*)memAlloc(&pGkClient->ctxt, 
+                                                sizeof(RasCallAdmissionInfo));
+      if(!pCallAdmInfo)
+      {
+         OOTRACEERR1("Error: Failed to allocate memory for new CallAdmission"
+                  " Info entry\n");
+         memReset(pctxt);
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      } 
+
+      pCallAdmInfo->call = call;
+      pCallAdmInfo->retries = 0;
+      pCallAdmInfo->requestSeqNum = pAdmReq->requestSeqNum;
+      dListAppend(&pGkClient->ctxt, &pGkClient->callsPendingList,pCallAdmInfo);
+   }
+   else{
+      for(x=0; x<pGkClient->callsPendingList.count; x++)
+      {
+         pNode = dListFindByIndex(&pGkClient->callsPendingList, x);
+         pCallAdmInfo = (RasCallAdmissionInfo*)pNode->data;
+         if(pCallAdmInfo->call->callReference == call->callReference)
+         {
+            pCallAdmInfo->requestSeqNum = pAdmReq->requestSeqNum;
+            break;
+         }
+      }
+   }
+   
+   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error:Failed to send AdmissionRequest message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   OOTRACEINFO3("Admission Request message sent for (%s, %s)\n", 
+                 call->callType, call->callToken);
+   memReset(pctxt);
+    
+   /* Add ARQ timer */
+   cbData = (ooGkClientTimerCb*) memAlloc
+                               (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
+   if(!cbData)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for Regisration timer."
+                  "\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   cbData->timerType = OO_ARQ_TIMER;
+   cbData->pGkClient = pGkClient;
+   cbData->pAdmInfo =  pCallAdmInfo;
+   if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, 
+                  &ooGkClientARQTimerExpired, pGkClient->arqTimeout, 
+                  cbData, FALSE))
+   {
+      OOTRACEERR1("Error:Unable to create ARQ timer.\n ");
+      memFreePtr(&pGkClient->ctxt, cbData);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }    
+   
+   return OO_OK;
+}
+
+/**
+ * Manage incoming ACF message.
+ */
+
+int ooGkClientHandleAdmissionConfirm
+   (ooGkClient *pGkClient, H225AdmissionConfirm *pAdmissionConfirm)
+{
+   RasCallAdmissionInfo* pCallAdmInfo=NULL;
+   unsigned int x, y;
+   DListNode *pNode, *pNode1=NULL;
+   H225TransportAddress_ipAddress * ipAddress=NULL;
+   OOTimer *pTimer = NULL;
+   char ip[20];
+
+   /* Search call in pending calls list */
+   for(x=0 ; x<pGkClient->callsPendingList.count; x++)
+   {
+      pNode = dListFindByIndex(&pGkClient->callsPendingList, x);
+      pCallAdmInfo = (RasCallAdmissionInfo*) pNode->data;
+      if(pCallAdmInfo->requestSeqNum == pAdmissionConfirm->requestSeqNum)
+      {
+         OOTRACEDBGC3("Found Pending call(%s, %s)\n", 
+                      pCallAdmInfo->call->callType, 
+                      pCallAdmInfo->call->callToken);
+         /* Populate Remote IP */
+         if(pAdmissionConfirm->destCallSignalAddress.t != 
+                                      T_H225TransportAddress_ipAddress)
+         {
+            OOTRACEERR1("Error:Destination Call Signal Address provided by"
+                        "Gatekeeper is not an IPv4 address\n");
+            OOTRACEINFO1("Ignoring ACF, will wait for timeout and retransmit "
+                         "ARQ\n");
+            return OO_FAILED;
+         }
+         ipAddress = pAdmissionConfirm->destCallSignalAddress.u.ipAddress;
+         
+         sprintf(ip, "%d.%d.%d.%d", ipAddress->ip.data[0],
+                                    ipAddress->ip.data[1],
+                                    ipAddress->ip.data[2],
+                                    ipAddress->ip.data[3]);
+         if(strcmp(ip, "0.0.0.0"))
+            strcpy(pCallAdmInfo->call->remoteIP, ip);
+         pCallAdmInfo->call->remotePort = ipAddress->port;
+         /* Update call model */
+         if(pAdmissionConfirm->callModel.t == T_H225CallModel_direct)
+         {
+            if(OO_TESTFLAG(pCallAdmInfo->call->flags, OO_M_GKROUTED))
+            {
+               OOTRACEINFO3("Gatekeeper changed call model from GkRouted to "
+                            "direct. (%s, %s)\n", pCallAdmInfo->call->callType,
+                            pCallAdmInfo->call->callToken);
+               OO_CLRFLAG(pCallAdmInfo->call->flags, OO_M_GKROUTED);
+            }
+         }
+         
+         if(pAdmissionConfirm->callModel.t == T_H225CallModel_gatekeeperRouted)
+         {
+            if(!OO_TESTFLAG(pCallAdmInfo->call->flags, OO_M_GKROUTED))
+            {
+               OOTRACEINFO3("Gatekeeper changed call model from direct to "
+                            "GkRouted. (%s, %s)\n", 
+                            pCallAdmInfo->call->callType,
+                            pCallAdmInfo->call->callToken);
+               OO_SETFLAG(pCallAdmInfo->call->flags, OO_M_GKROUTED);
+            }
+         }
+
+         /* Delete ARQ timer */
+         for(y=0; y<pGkClient->timerList.count; y++)
+         {
+            pNode1 =  dListFindByIndex(&pGkClient->timerList, y);
+            pTimer = (OOTimer*)pNode1->data;
+            if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_ARQ_TIMER)
+            {
+               if(((ooGkClientTimerCb*)pTimer->cbData)->pAdmInfo == 
+                                                                 pCallAdmInfo)
+               {
+                  memFreePtr(&pGkClient->ctxt, pTimer->cbData);
+                  ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, 
+                                                                       pTimer);
+                  OOTRACEDBGA1("Deleted ARQ Timer.\n");
+                  break;
+               }
+            }
+         }       
+         OOTRACEINFO3("Admission Confirm message received for (%s, %s)\n", 
+                       pCallAdmInfo->call->callType, 
+                       pCallAdmInfo->call->callToken);  
+         ooH323CallAdmitted( pCallAdmInfo->call);
+         dListRemove(&pGkClient->callsPendingList, pNode);
+         dListAppend(&pGkClient->ctxt, &pGkClient->callsAdmittedList, 
+                                                        pNode->data);
+         memFreePtr(&pGkClient->ctxt, pNode);
+         return OO_OK;
+         break;
+      }
+      else
+      {
+         pNode = pNode->next;
+      }
+   }
+   OOTRACEERR1("Error: Failed to process ACF as there is no corresponding "
+               "pending call\n");
+   return OO_OK;
+}
+
+
+int ooGkClientHandleAdmissionReject
+   (ooGkClient *pGkClient, H225AdmissionReject *pAdmissionReject)
+{
+   RasCallAdmissionInfo* pCallAdmInfo=NULL;
+   unsigned int x;
+   DListNode *pNode=NULL;
+   OOH323CallData *call=NULL;
+
+   /* Search call in pending calls list */
+   for(x=0 ; x<pGkClient->callsPendingList.count; x++)
+   {
+      pNode = dListFindByIndex(&pGkClient->callsPendingList, x);
+      pCallAdmInfo = (RasCallAdmissionInfo*) pNode->data;
+      if(pCallAdmInfo->requestSeqNum == pAdmissionReject->requestSeqNum)
+         break;
+      pNode = NULL;
+      pCallAdmInfo = NULL;
+   }
+
+   if(!pCallAdmInfo)
+   {
+      OOTRACEWARN2("Received admission reject with request number %d can not"
+                   " be matched with any pending call.\n", 
+                   pAdmissionReject->requestSeqNum);
+      return OO_OK;
+   }
+   else{
+      call = pCallAdmInfo->call;
+      dListRemove(&pGkClient->callsPendingList, pNode);
+      memFreePtr(&pGkClient->ctxt, pCallAdmInfo);
+      memFreePtr(&pGkClient->ctxt, pNode);
+   }
+
+   OOTRACEINFO4("Admission Reject message received with reason code %d for "
+                "(%s, %s)\n", pAdmissionReject->rejectReason.t, call->callType,
+                 call->callToken);
+   
+   call->callState = OO_CALL_CLEAR;
+
+   switch(pAdmissionReject->rejectReason.t)
+   {
+      case T_H225AdmissionRejectReason_calledPartyNotRegistered:
+         call->callEndReason = OO_REASON_GK_NOCALLEDUSER;
+         break;
+      case T_H225AdmissionRejectReason_invalidPermission:
+      case T_H225AdmissionRejectReason_requestDenied:
+      case T_H225AdmissionRejectReason_undefinedReason:
+         call->callEndReason = OO_REASON_GK_CLEARED;
+         break;
+      case T_H225AdmissionRejectReason_callerNotRegistered:
+         call->callEndReason = OO_REASON_GK_NOCALLERUSER;
+         break;
+      case T_H225AdmissionRejectReason_exceedsCallCapacity:
+      case T_H225AdmissionRejectReason_resourceUnavailable:
+         call->callEndReason = OO_REASON_GK_NORESOURCES;
+         break;
+      case T_H225AdmissionRejectReason_noRouteToDestination:
+      case T_H225AdmissionRejectReason_unallocatedNumber:
+         call->callEndReason = OO_REASON_GK_UNREACHABLE;
+         break;
+      case T_H225AdmissionRejectReason_routeCallToGatekeeper:
+      case T_H225AdmissionRejectReason_invalidEndpointIdentifier:
+      case T_H225AdmissionRejectReason_securityDenial:
+      case T_H225AdmissionRejectReason_qosControlNotSupported:
+      case T_H225AdmissionRejectReason_incompleteAddress:
+      case T_H225AdmissionRejectReason_aliasesInconsistent:
+      case T_H225AdmissionRejectReason_routeCallToSCN:
+      case T_H225AdmissionRejectReason_collectDestination:
+      case T_H225AdmissionRejectReason_collectPIN:
+      case T_H225AdmissionRejectReason_genericDataReason:
+      case T_H225AdmissionRejectReason_neededFeatureNotSupported:
+      case T_H225AdmissionRejectReason_securityErrors:
+      case T_H225AdmissionRejectReason_securityDHmismatch:
+      case T_H225AdmissionRejectReason_extElem1:
+         call->callEndReason = OO_REASON_GK_CLEARED;
+         break;
+   }
+
+   return OO_OK;   
+}
+
+/**
+ * This function is invoked to request call disengage to gatekeeper. 
+ * 
+ * @param   szCallToken    Call token.     
+ *
+ * @return  Completion status - 0 on success, -1 on failure
+ */
+
+int ooGkClientSendDisengageRequest(ooGkClient *pGkClient, OOH323CallData *call)
+{
+   int iRet = 0;   
+   unsigned int x;
+   H225RasMessage *pRasMsg=NULL;
+   OOCTXT *pctxt = NULL;
+   DListNode *pNode = NULL;
+   H225DisengageRequest * pDRQ = NULL;
+   RasCallAdmissionInfo* pCallAdmInfo=NULL;
+   pctxt = &pGkClient->msgCtxt;
+
+   OOTRACEINFO3("Sending disengage Request for  call. (%s, %s)\n",
+                 call->callType, call->callToken);
+
+   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
+   if(!pRasMsg)
+   {
+      OOTRACEERR1("Error: Memory allocation for DRQ RAS message failed\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+
+   pRasMsg->t = T_H225RasMessage_disengageRequest;
+   pDRQ = (H225DisengageRequest*) memAlloc(pctxt, 
+                                               sizeof(H225DisengageRequest));
+   if(!pDRQ)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for DRQ message\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+
+   memset(pDRQ, 0, sizeof(H225DisengageRequest));
+   pRasMsg->u.disengageRequest = pDRQ;
+   
+   pDRQ->requestSeqNum = pGkClient->requestSeqNum++;
+   if(!pDRQ->requestSeqNum )
+      pDRQ->requestSeqNum = pGkClient->requestSeqNum++;
+   
+   
+   pDRQ->endpointIdentifier.nchars = pGkClient->endpointId.nchars;
+   pDRQ->endpointIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt,
+                           sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
+   if(!pDRQ->endpointIdentifier.data)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for EndPoint Id in DRQ "
+                  "message.\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memcpy((void*)pDRQ->endpointIdentifier.data, 
+                 (void*)pGkClient->endpointId.data, 
+                 sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
+
+   memcpy((void*)&pDRQ->conferenceID, (void*)&call->confIdentifier,
+                                         sizeof(H225ConferenceIdentifier));
+
+   pDRQ->callReferenceValue = call->callReference;
+   
+   pDRQ->disengageReason.t = T_H225DisengageReason_normalDrop;
+
+   pDRQ->m.answeredCallPresent = 1;
+   if(!strcmp(call->callType, "incoming"))
+      pDRQ->answeredCall = 1;
+   else
+      pDRQ->answeredCall = 0;
+
+   pDRQ->m.callIdentifierPresent = 1;
+   memcpy((void*)&pDRQ->callIdentifier, (void*)&call->callIdentifier,
+                                             sizeof(H225CallIdentifier));
+   pDRQ->m.gatekeeperIdentifierPresent = 1;
+   pDRQ->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars;
+   pDRQ->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc
+                       (pctxt, pGkClient->gkId.nchars*sizeof(ASN116BITCHAR));
+   if(!pDRQ->gatekeeperIdentifier.data)
+   {
+      OOTRACEERR1("Error:Failed to allocate memory for GKId in DRQ.\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   memcpy(pDRQ->gatekeeperIdentifier.data, pGkClient->gkId.data, 
+                                pGkClient->gkId.nchars*sizeof(ASN116BITCHAR));
+
+   pDRQ->m.terminationCausePresent = 1;
+   pDRQ->terminationCause.t = T_H225CallTerminationCause_releaseCompleteCauseIE;
+   pDRQ->terminationCause.u.releaseCompleteCauseIE = 
+      (H225CallTerminationCause_releaseCompleteCauseIE*)memAlloc(pctxt,
+      sizeof(H225CallTerminationCause_releaseCompleteCauseIE));
+   if(!pDRQ->terminationCause.u.releaseCompleteCauseIE)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for cause ie in DRQ.\n");
+      memReset(pctxt);
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   pDRQ->terminationCause.u.releaseCompleteCauseIE->numocts = 
+                                                         strlen("Call Ended");
+   strcpy(pDRQ->terminationCause.u.releaseCompleteCauseIE->data, "Call Ended");
+
+   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR1("Error: Failed to send DRQ message\n");
+      pGkClient->state = GkClientFailed;
+   }
+   
+
+
+   /* Search call in admitted calls list */
+   for(x=0 ; x<pGkClient->callsAdmittedList.count ; x++)
+   {
+      pNode = (DListNode*)dListFindByIndex(&pGkClient->callsAdmittedList, x);
+      pCallAdmInfo = (RasCallAdmissionInfo*) pNode->data;
+      if(pCallAdmInfo->call->callReference == call->callReference)
+      {
+         dListRemove( &pGkClient->callsAdmittedList, pNode);
+         memFreePtr(&pGkClient->ctxt, pNode->data);
+         memFreePtr(&pGkClient->ctxt, pNode);
+         break;
+      }
+   }
+   return iRet;
+}     
+
+int ooGkClientHandleDisengageConfirm
+   (ooGkClient *pGkClient, H225DisengageConfirm *pDCF)
+{
+   OOTRACEINFO1("Received disengage confirm\n");
+   return OO_OK;
+}
+
+int ooGkClientRRQTimerExpired(void*pdata)
+{
+   int ret=0;
+   ooGkClientTimerCb *cbData = (ooGkClientTimerCb*)pdata;
+   ooGkClient *pGkClient = cbData->pGkClient;
+   OOTRACEDBGA1("Gatekeeper client RRQ timer expired.\n");
+   
+   if(pGkClient->rrqRetries < OO_MAX_RRQ_RETRIES)
+   {
+      ret = ooGkClientSendRRQ(pGkClient, 0);      
+      if(ret != OO_OK)
+      {
+         OOTRACEERR1("Error:Failed to send RRQ message\n");
+         
+         return OO_FAILED;
+      }
+      pGkClient->rrqRetries++;
+      memFreePtr(&pGkClient->ctxt, cbData);
+      return OO_OK;
+   }
+   memFreePtr(&pGkClient->ctxt, cbData);
+   OOTRACEERR1("Error:Failed to register with gatekeeper\n");
+   pGkClient->state = GkClientGkErr;
+   return OO_FAILED;
+}
+
+int ooGkClientGRQTimerExpired(void* pdata)
+{
+   int ret=0;
+   ooGkClientTimerCb *cbData = (ooGkClientTimerCb*)pdata;
+   ooGkClient *pGkClient = cbData->pGkClient;
+
+   OOTRACEDBGA1("Gatekeeper client GRQ timer expired.\n");
+
+   memFreePtr(&pGkClient->ctxt, cbData);   
+
+   if(pGkClient->grqRetries < OO_MAX_GRQ_RETRIES)
+   {
+      ret = ooGkClientSendGRQ(pGkClient);      
+      if(ret != OO_OK)
+      {
+         OOTRACEERR1("Error:Failed to send GRQ message\n");
+         pGkClient->state = GkClientFailed;
+         return OO_FAILED;
+      }
+      pGkClient->grqRetries++;
+      return OO_OK;
+   }
+
+   OOTRACEERR1("Error:Gatekeeper could not be found\n");
+   pGkClient->state = GkClientGkErr;
+   return OO_FAILED;
+}
+   
+int ooGkClientREGTimerExpired(void *pdata)
+{
+   int ret=0;
+   ooGkClientTimerCb *cbData = (ooGkClientTimerCb*)pdata;
+   ooGkClient *pGkClient = cbData->pGkClient;
+   OOTRACEDBGA1("Gatekeeper client additive registration timer expired\n");
+   memFreePtr(&pGkClient->ctxt, cbData);   
+   ret = ooGkClientSendRRQ(pGkClient, TRUE);      
+   if(ret != OO_OK)
+   {
+      OOTRACEERR1("Error:Failed to send Additive RRQ message\n");
+      pGkClient->state = GkClientFailed;
+      return OO_FAILED;
+   }
+   return OO_OK;
+}
+
+int ooGkClientARQTimerExpired(void* pdata)
+{
+   int ret=0;
+   ooGkClientTimerCb *cbData = (ooGkClientTimerCb*)pdata;
+   ooGkClient *pGkClient = cbData->pGkClient;
+   RasCallAdmissionInfo *pAdmInfo = cbData->pAdmInfo;
+
+   OOTRACEDBGA1("Gatekeeper client ARQ timer expired.\n");
+   memFreePtr(&pGkClient->ctxt, cbData);   
+
+   if(pAdmInfo->retries < OO_MAX_ARQ_RETRIES)
+   {
+      ret = ooGkClientSendAdmissionRequest(pGkClient, pAdmInfo->call, TRUE);      
+      if(ret != OO_OK)
+      {
+         OOTRACEERR1("Error:Failed to send ARQ message\n");
+         return OO_FAILED;
+      }
+      pAdmInfo->retries++;
+      return OO_OK;
+   }
+
+   OOTRACEERR1("Error:Gatekeeper not responding to ARQ\n");
+   pGkClient->state = GkClientGkErr;
+   return OO_FAILED;
+}
+
+int ooGkClientCleanCall(ooGkClient *pGkClient, OOH323CallData *call)
+{
+   unsigned int x=0;
+   DListNode *pNode=NULL;
+   OOTimer *pTimer;
+   ooGkClientTimerCb *cbData=NULL;
+   RasCallAdmissionInfo *pAdmInfo = NULL;
+
+
+   for(x=0; x<pGkClient->callsAdmittedList.count; x++)
+   {
+      pNode = dListFindByIndex(&pGkClient->callsAdmittedList, x);
+      pAdmInfo = (RasCallAdmissionInfo*)pNode->data;
+      if(pAdmInfo->call->callReference == call->callReference)
+      {
+         dListRemove(&pGkClient->callsAdmittedList, pNode);
+         memFreePtr(&pGkClient->ctxt, pAdmInfo);
+         memFreePtr(&pGkClient->ctxt, pNode);
+         return OO_OK;
+      }
+   }
+
+
+   for(x=0; x<pGkClient->timerList.count; x++)
+   {
+      pNode = dListFindByIndex(&pGkClient->timerList, x);
+      pTimer = (OOTimer*)pNode->data;
+      cbData = (ooGkClientTimerCb*)pTimer->cbData;
+      if(cbData->timerType & OO_ARQ_TIMER &&
+         cbData->pAdmInfo->call->callReference == call->callReference)
+      {
+         memFreePtr(&pGkClient->ctxt, pTimer->cbData);
+         ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer);
+         break;
+      }
+   }
+
+   for(x=0; x<pGkClient->callsPendingList.count; x++)
+   {
+      pNode = dListFindByIndex(&pGkClient->callsPendingList, x);
+      pAdmInfo = (RasCallAdmissionInfo*)pNode->data;
+      if(pAdmInfo->call->callReference == call->callReference)
+      {
+         dListRemove(&pGkClient->callsPendingList, pNode);
+         memFreePtr(&pGkClient->ctxt, pAdmInfo);
+         memFreePtr(&pGkClient->ctxt, pNode);
+         return OO_OK;
+      }
+   }
+
+   return OO_OK;
+}
+
+/*
+ * TODO: In case of GkErr, if GkMode is DiscoverGatekeeper,
+ *       need to cleanup gkrouted calls, and discover another
+ *       gatekeeper.
+ * Note: This function returns OO_FAILED, when we can not recover from
+ *       the failure.
+ */
+int ooGkClientHandleClientOrGkFailure(ooGkClient *pGkClient)
+{
+   if(pGkClient->state == GkClientFailed)
+   {
+      OOTRACEERR1("Error: Internal Failure in GkClient. Closing "
+                  "GkClient\n");
+      ooGkClientDestroy();
+      return OO_FAILED;
+   }
+   else if(pGkClient->state == GkClientGkErr) {
+      OOTRACEERR1("Error: Gatekeeper error. Either Gk not responding or "
+                  "Gk sending invalid messages\n");
+      if(pGkClient->gkMode == RasUseSpecificGatekeeper)
+      {
+         OOTRACEERR1("Error: Gatekeeper error detected. Closing GkClient as "
+                     "Gk mode is UseSpecifcGatekeeper\n");
+         ooGkClientDestroy();
+         return OO_FAILED;
+      }
+      else{
+         OOTRACEERR1("Error: Gatekeeper error detected. Closing GkClient. NEED"
+                    " to implement recovery by rediscovering another gk\n");
+         ooGkClientDestroy();
+         return OO_FAILED;
+      }
+   }
+
+   return OO_FAILED;
+}
+
+/**
+ * TODO: This fuction might not work properly in case of additive registrations
+ * For example we registrered 10 aliases and gatekeeper accepted 8 of them.
+ * Now we want to register another two new aliases(not out of those first 10).
+ * Gk responds with RCF with empty terminalAlias field thus indicating both 
+ * the aliases were accepted. If this function is called, it will even mark
+ * the earlier two unregistered aliases as registered. We will have to
+ * maintain a separete list of aliases being sent in RRQ for this.
+ */
+int ooGkClientUpdateRegisteredAliases
+   (ooGkClient *pGkClient, H225_SeqOfH225AliasAddress *pAddresses, 
+    OOBOOL registered)
+{
+   int i=0, j, k;
+   DListNode* pNode=NULL;
+   ooAliases *pAlias=NULL;
+   H225AliasAddress *pAliasAddress=NULL;
+   H225TransportAddress *pTransportAddrss=NULL;
+   char value[MAXFILENAME];
+   OOBOOL bAdd = FALSE;
+
+   if(!pAddresses)
+   {
+     /* All aliases registered/unregistsred */
+      pAlias = gH323ep.aliases;
+      
+      while(pAlias)
+      {
+         pAlias->registered = registered?TRUE:FALSE;
+         pAlias = pAlias->next;
+      }
+      return OO_OK;
+   }
+
+   /* Mark aliases as registered/unregistered*/
+   if(pAddresses->count<=0)
+      return OO_FAILED;
+
+   for(i=0; i<(int)pAddresses->count; i++)
+   {
+      pNode = dListFindByIndex (pAddresses, i);
+      if(!pNode)
+      {
+         OOTRACEERR1("Error:Invalid alias list passed to "
+                     "ooGkClientUpdateRegisteredAliases\n");
+         continue;
+      }
+      pAliasAddress = (H225AliasAddress*)pNode->data;
+      
+      if(!pAliasAddress){
+         OOTRACEERR1("Error:Invalid alias list passed to "
+                     "ooGkClientUpdateRegisteredAliases\n");
+         continue;
+      }
+
+      switch(pAliasAddress->t)
+      {
+      case T_H225AliasAddress_dialedDigits:
+         pAlias = ooH323GetAliasFromList(gH323ep.aliases, 
+                                          T_H225AliasAddress_dialedDigits, 
+                                        (char*)pAliasAddress->u.dialedDigits);
+         if(pAlias)
+         {
+            pAlias->registered = registered?TRUE:FALSE;
+         }
+         else{
+            bAdd = registered?TRUE:FALSE;
+         }
+         break;
+      case T_H225AliasAddress_h323_ID:
+         for(j=0, k=0; j<(int)pAliasAddress->u.h323_ID.nchars && (k<MAXFILENAME-1); j++)
+         {
+            if(pAliasAddress->u.h323_ID.data[j] < 256)
+            {
+               value[k++] = (char) pAliasAddress->u.h323_ID.data[j];
+            }
+         }
+         value[k] = '\0';
+         pAlias = ooH323GetAliasFromList(gH323ep.aliases, 
+                                         T_H225AliasAddress_h323_ID, 
+                                          value);
+         if(pAlias)
+         {
+            pAlias->registered = registered?TRUE:FALSE;
+         }
+         else{
+            bAdd = registered?TRUE:FALSE;
+         }
+         break;
+      case T_H225AliasAddress_url_ID:
+         pAlias = ooH323GetAliasFromList(gH323ep.aliases, 
+                                         T_H225AliasAddress_url_ID, 
+                                       (char*)pAliasAddress->u.url_ID);
+         if(pAlias)
+         {
+            pAlias->registered = registered?TRUE:FALSE;
+         }
+         else{
+            bAdd = registered?TRUE:FALSE;
+         }
+         break;
+      case T_H225AliasAddress_transportID:
+         pTransportAddrss = pAliasAddress->u.transportID;
+         if(pTransportAddrss->t != T_H225TransportAddress_ipAddress)
+         {
+            OOTRACEERR1("Error:Alias transportID not IP address\n");
+            break;
+         }
+         
+         sprintf(value, "%d.%d.%d.%d:%d", 
+                          pTransportAddrss->u.ipAddress->ip.data[0],
+                          pTransportAddrss->u.ipAddress->ip.data[1],
+                          pTransportAddrss->u.ipAddress->ip.data[2],
+                          pTransportAddrss->u.ipAddress->ip.data[3],
+                          pTransportAddrss->u.ipAddress->port);
+
+         pAlias = ooH323GetAliasFromList(gH323ep.aliases, 
+                                         T_H225AliasAddress_transportID, 
+                                         value);
+         if(pAlias)
+         {
+            pAlias->registered = registered?TRUE:FALSE;
+         }
+         else{
+            bAdd = registered?TRUE:FALSE;
+         }
+         break;
+      case T_H225AliasAddress_email_ID:
+         pAlias = ooH323GetAliasFromList(gH323ep.aliases, 
+                                         T_H225AliasAddress_email_ID, 
+                                       (char*) pAliasAddress->u.email_ID);
+         if(pAlias)
+         {
+            pAlias->registered = registered?TRUE:FALSE;
+         }
+         else{
+            bAdd = registered?TRUE:FALSE;
+         }
+         break;
+      default:
+         OOTRACEERR1("Error:Unhandled alias type found in registered "
+                     "aliases\n");
+      }
+      if(bAdd)
+      {
+         pAlias = ooH323AddAliasToList(&gH323ep.aliases, 
+                                           &gH323ep.ctxt, pAliasAddress);
+         if(pAlias){
+            pAlias->registered = registered?TRUE:FALSE;
+         }
+         else{
+            OOTRACEERR2("Warning:Could not add registered alias of "
+                        "type %d to list.\n", pAliasAddress->t);
+         }
+         bAdd = FALSE;
+      }
+      pAlias = NULL;
+   }
+   return OO_OK;
+}
diff --git a/addons/ooh323c/src/ooGkClient.h b/addons/ooh323c/src/ooGkClient.h
new file mode 100644
index 000000000..fa52f3e92
--- /dev/null
+++ b/addons/ooh323c/src/ooGkClient.h
@@ -0,0 +1,560 @@
+/*
+ * Copyright (C) 2005 by Page Iberica, S.A.
+ * Copyright (C) 2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/**
+ * @file ooGkClient.h 
+ * This file contains functions to support RAS protocol. 
+ *
+ *
+ */
+#ifndef _OOGKCLIENT_H_
+#define _OOGKCLIENT_H_
+
+#include "ooasn1.h"
+#include "ootypes.h"
+#include "H323-MESSAGES.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* _WIN32 */
+#endif /* EXTERN */
+
+
+/*-------------------------------------------------------------------*/
+/*  Public definitions                                               */
+/*-------------------------------------------------------------------*/
+
+
+
+#define MAX_IP_LEN 15
+#define DEFAULT_GKPORT 1719
+#define MULTICAST_GKADDRESS "224.0.1.41"
+#define MULTICAST_GKPORT 1718
+#define DEFAULT_BW_REQUEST  100000
+
+/* Various timeouts in seconds */
+#define DEFAULT_REG_TTL 300
+#define DEFAULT_TTL_OFFSET 20
+#define DEFAULT_ARQ_TIMEOUT 5
+#define DEFAULT_DRQ_TIMEOUT 5
+#define DEFAULT_GRQ_TIMEOUT 15
+#define DEFAULT_RRQ_TIMEOUT 10
+
+/* Number of retries before giving up */
+#define OO_MAX_GRQ_RETRIES 3
+#define OO_MAX_RRQ_RETRIES 3
+#define OO_MAX_ARQ_RETRIES 3
+
+/* Gk Client timers */
+#define OO_GRQ_TIMER (1<<0)
+#define OO_RRQ_TIMER (1<<1)
+#define OO_REG_TIMER (1<<2)
+#define OO_ARQ_TIMER (1<<3)
+#define OO_DRQ_TIMER (1<<4)
+
+/** 
+ * @defgroup gkclient Gatekeeper client
+ * @{
+ */
+
+struct OOH323CallData;
+struct ooGkClient;
+struct RasCallAdmissionInfo;
+
+typedef struct ooGkClientTimerCb{
+   int timerType;
+   struct ooGkClient *pGkClient;
+   struct RasCallAdmissionInfo *pAdmInfo;
+}ooGkClientTimerCb;
+
+enum RasGatekeeperMode {
+   RasNoGatekeeper = 0,
+   RasDiscoverGatekeeper = 1,
+   RasUseSpecificGatekeeper = 2,
+};
+
+enum RasCallType{
+   RasPointToPoint =0,
+   RasOneToN,
+   RasnToOne,
+   RasnToN,
+};
+
+
+enum OOGkClientState {
+   GkClientIdle = 0,
+   GkClientDiscovered, /* Gk Discovery is complete */
+   GkClientRegistered, /* registered with gk */
+   GkClientUnregistered,
+   GkClientGkErr,/*Gk is not responding, in discover mode can look for new GK*/
+   GkClientFailed
+};
+   
+
+typedef struct RasGatekeeperInfo
+{
+   ASN1BOOL willRespondToIRR;
+   H225UUIEsRequested uuiesRequested;
+   H225BandWidth bw;
+   H225RegistrationConfirm_preGrantedARQ preGrantedARQ;
+}RasGatekeeperInfo;
+
+/**
+ *  Call Admission Information
+ */
+typedef struct RasCallAdmissionInfo
+{
+   struct OOH323CallData *call;
+   unsigned int retries;
+   unsigned short requestSeqNum;
+   ASN1USINT irrFrequency;
+} RasCallAdmissionInfo;
+
+struct OOAliases;
+
+/**
+ * NOTE- This functionality is not yet fully completed.
+ * This is a callback function which is triggered when registration confirm 
+ * message is received from the gatekeeper. The first parameter is the message
+ * received. The second parameter provides updated list of aliases after the 
+ * message was processed by the stack.
+ * @param rcf  Handle to the received registration confirm message
+ */
+typedef int (*cb_OnReceivedRegistrationConfirm)
+     (H225RegistrationConfirm *rcf, struct OOAliases *aliases);
+
+
+/**
+ * NOTE- This functionality is not yet fully completed.
+ * This is a callback function which is triggered when unregistration confirm 
+ * message is received. The first parameter is the message received. The second
+ * parameter provides updated list of aliases after the message was processed 
+ * by the stack.
+ */
+typedef int (*cb_OnReceivedUnregistrationConfirm)
+     (H225UnregistrationConfirm *ucf, struct OOAliases *aliases);
+
+/**
+ * NOTE- This functionality is not yet fully completed.
+ * This is a callback function which is triggered when unregistration request 
+ * message is received. The first parameter is the message received. The second
+ * parameter provides the list of aliases requested to be unregistered.
+ */
+typedef int (*cb_OnReceivedUnregistrationRequest)
+     (H225UnregistrationRequest *urq, struct OOAliases *aliases);
+
+typedef struct OOGKCLIENTCALLBACKS{
+   cb_OnReceivedRegistrationConfirm onReceivedRegistrationConfirm;
+   cb_OnReceivedUnregistrationConfirm onReceivedUnregistrationConfirm;
+   cb_OnReceivedUnregistrationRequest onReceivedUnregistrationRequest;
+}OOGKCLIENTCALLBACKS;
+
+/**
+ * Structure to store all the configuration information for the gatekeeper
+ * client. Gatekeeper client is responsible for all the communication with
+ * a gatekeeper.
+ */
+typedef struct ooGkClient{
+   ASN1BOOL discoveryComplete;
+   OOCTXT ctxt;
+   OOCTXT msgCtxt;
+   OOSOCKET rasSocket;
+   int localRASPort;
+   char localRASIP[20];
+   char gkRasIP[20];
+   char gkCallSignallingIP[20];
+   RasGatekeeperInfo gkInfo;
+   int gkRasPort;
+   int gkCallSignallingPort;
+   unsigned short requestSeqNum;
+   enum RasGatekeeperMode gkMode; /* Current Gk mode */
+   struct timeval registrationTime;
+   H225GatekeeperIdentifier gkId;
+   H225EndpointIdentifier endpointId;
+   DList callsPendingList;
+   DList callsAdmittedList;
+   DList timerList;
+   OOGKCLIENTCALLBACKS callbacks;
+   ASN1UINT grqRetries;
+   ASN1UINT rrqRetries;
+   ASN1UINT grqTimeout;
+   ASN1UINT rrqTimeout;
+   ASN1UINT regTimeout;
+   ASN1UINT arqTimeout;
+   ASN1UINT drqTimeout;
+   enum OOGkClientState  state;
+} ooGkClient;
+
+struct OOAliases;
+struct OOH323CallData;
+
+/**
+ * This function is used to initialize the Gatekeeper client.If an application
+ * wants to use gatekeeper services, it should call this function immediately
+ * after initializing the H323 EndPoint.
+ * @param eGkMode          Gatekeeper mode.
+ * @param szGkAddr         Dotted gk ip address, if gk has to be specified.
+ * @param iGkPort          Gk port.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ * 
+ */
+EXTERN int ooGkClientInit
+   (enum RasGatekeeperMode eGkMode, char *szGkAddr, int iGkPort );
+
+/**
+ * This function is used to print the gatekeeper client configuration 
+ * information to log.
+ * @param pGkClient        Handle to gatekeeper client.
+ */
+EXTERN void ooGkClientPrintConfig(ooGkClient *pGkClient);
+
+/**
+ * This function is used to destroy Gatekeeper client. It releases all the 
+ * associated memory.
+ *
+ * @return     OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientDestroy(void);
+
+/**
+ * This function is used to start the Gatekeeper client functionality.
+ * @param pGkClient        Pointer to the Gatekeeper Client.
+ * 
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientStart(ooGkClient *pGkClient);
+
+/**
+ * This function is invoked to set a gatekeeper mode. 
+ * @param pGkClient Handle to gatekeeper client. 
+ * @param eGkMode   Gatekeeper mode selected. One of the following: 
+ *                    - RasNoGatekeeper (DEFAULT), No Gatekeeper.              
+ *                    - RasDiscoverGatekeeper, to discover a gatekeeper 
+ *                      automatically.
+ *                    - RasUseSpecificGatekeeper, to use a specific gatekeeper.
+ * @param szGkAddr  Gatekeeper address (only when using specific gatekeeper).
+ * @param iGkPort   Gatekeeper RAS port
+ *
+ * @return         Completion status - OO_OK on success, OO_FAILED on failure
+ */
+EXTERN int ooGkClientSetGkMode(ooGkClient *pGkClient, 
+                               enum RasGatekeeperMode eGkMode, char *szGkAddr, 
+                               int iGkPort );
+
+/**
+ * This function is used to create a RAS channel for the gatekeeper.
+ * @param pGkClient     Pointer to the Gatekeeper client for which RAS channel
+ *                      has to be created.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientCreateChannel(ooGkClient *pGkClient);
+
+/**
+ * This function is used to close a RAS channel of the gatekeeper client.
+ * @param pGkClient    Pointer to the gatekeeper client.
+ *
+ * @return             OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientCloseChannel(ooGkClient *pGkClient);
+
+
+/**
+ * This function is used to fill endpoint's vendor information into vendor
+ * identifier.
+ * @param pGkClient    Pointer to gatekeeper client.
+ * @param psVendor     Pointer to vendor identifier to be filled.
+ * 
+ */
+EXTERN void ooGkClientRasFillVendor
+   (ooGkClient *pGkClient, H225VendorIdentifier *psVendor);
+
+
+/**
+ * This function is invoked to receive data on Gatekeeper client's RAS channel.
+ * @param pGkClient    Handle to Gatekeeper client for which message has to be
+ *                     received.
+ *
+ * @return             Completion status - OO_OK on success, OO_FAILED on 
+ *                     failure
+ */
+EXTERN int ooGkClientReceive(ooGkClient *pGkClient);
+
+
+/**
+ * This function is used to handle a received RAS message by a gatekeeper 
+ * client.
+ * @param pGkClient   Handle to gatekeeper client.
+ * @param pRasMsg     Handle to received Ras message.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientHandleRASMessage
+   (ooGkClient *pGkClient, H225RasMessage *pRasMsg);
+
+
+/**
+ * This function is used to send a message on Gatekeeper clien't RAS channel.
+ * @param pGkClient   Handle to the gatekeeper client.
+ * @param pRasMsg     Handle to Ras message to be sent.
+ *
+ * @return            OO_OK, on success. OO_FAILED, otherwise. 
+ */
+EXTERN int ooGkClientSendMsg(ooGkClient *pGkClient, H225RasMessage *pRasMsg);
+
+
+/**
+ * This function is used to send Gatekeeper request message.
+ * @param pGkClient  Handle to gatekeeper client for which GRQ message has to 
+ *                   be sent.
+ *
+ * @return           OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientSendGRQ(ooGkClient *pGkClient);
+
+
+/**
+ * This function is used to handle a received gatekeeper reject message.
+ * @param pGkClient          Handle to gatekeeper client.
+ * @param pGatekeeperReject  Handle to received reject message.
+ *
+ * @return                   OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientHandleGatekeeperReject
+   (ooGkClient *pGkClient, H225GatekeeperReject *pGatekeeperReject);
+
+/**
+ * This function is used to handle a received gatekeeper confirm message.
+ * @param pGkClient          Handle to gatekeeper client.
+ * @param pGatekeeperConfirm Handle to received confirmed message.
+ *
+ * @return                   OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientHandleGatekeeperConfirm
+   (ooGkClient *pGkClient, H225GatekeeperConfirm *pGatekeeperConfirm);
+
+
+/**
+ * This function is used to send Registration request message.
+ * @param pGkClient  Handle to gatekeeper client for which RRQ message has to 
+ *                   be sent.
+ * @param keepAlive  Indicates whether keepalive lightweight registration has 
+ *                   to be sent.
+ *
+ * @return           OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientSendRRQ(ooGkClient *pGkClient, ASN1BOOL keepAlive);
+
+/**
+ * This function is used to handle a received registration confirm message.
+ * @param pGkClient            Handle to gatekeeper client.
+ * @param pRegistrationConfirm Handle to received confirmed message.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientHandleRegistrationConfirm
+   (ooGkClient *pGkClient, H225RegistrationConfirm *pRegistrationConfirm);
+
+/**
+ * This function is used to handle a received registration reject message.
+ * @param pGkClient           Handle to gatekeeper client.
+ * @param pRegistrationReject Handle to received reject message.
+ *
+ * @return                    OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientHandleRegistrationReject
+   (ooGkClient *pGkClient, H225RegistrationReject *pRegistrationReject);
+
+
+/**
+ * This function is used to send UnRegistration request message.
+ * @param pGkClient  Handle to gatekeeper client for which URQ message has to 
+ *                   be sent.
+ * @param aliases    List of aliases to be unregistered. NULL, if all the 
+ *                   aliases have to be unregistered.
+ *
+ * @return           OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientSendURQ(ooGkClient *pGkClient, struct OOAliases *aliases);
+
+/**
+ * This function is used to handle a received Unregistration request message.
+ * @param pGkClient              Handle to gatekeeper client.
+ * @param punregistrationRequest Handle to received unregistration request.
+ *
+ * @return                   OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientHandleUnregistrationRequest
+   (ooGkClient *pGkClient, H225UnregistrationRequest *punregistrationRequest);
+
+
+/**
+ * This function is used to send an unregistration confirm messsage to 
+ * gatekeeper.
+ * @param pGkClient        Handle to gatekeeper client.
+ * @param reqNo            Request Sequence number for the confirm message.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientSendUnregistrationConfirm(ooGkClient *pGkClient, 
+                                                               unsigned reqNo);
+
+/**
+ * This function is invoked to request bandwith admission for a call. 
+ * @param pGkClient     Gatekeeper client to be used
+ * @param call          Handle to the call.
+ * @param retransmit    Indicates whether new call or retransmitting for 
+ *                      existing call.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientSendAdmissionRequest
+   (ooGkClient *pGkClient, struct OOH323CallData *call, ASN1BOOL retransmit);
+
+/**
+ * This function is used to handle a received Admission confirm message.
+ * @param pGkClient         Handle to gatekeeper client.
+ * @param pAdmissionConfirm Handle to received confirmed message.
+ *
+ * @return                  OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientHandleAdmissionConfirm
+   (ooGkClient *pGkClient, H225AdmissionConfirm *pAdmissionConfirm);
+
+
+/**
+ * This function is used to handle a received Admission Reject message. It 
+ * finds the associated call and marks it for cleaning with appropriate 
+ * call end reason code.
+ * @param pGkClient         Handle to Gatekeeper client.
+ * @param pAdmissionReject  Handle to received admission reject message.
+ *
+ * @return                  OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientHandleAdmissionReject
+   (ooGkClient *pGkClient, H225AdmissionReject *pAdmissionReject);
+
+/**
+ * This function is invoked to request call disengage to gatekeeper. 
+ * @param pGkClient  Gatekeeper client to be used.
+ * @param call       Call Handle
+ *
+ * @return           Completion status - OO_OK on success, OO_FAILED on failure
+ */
+EXTERN int ooGkClientSendDisengageRequest
+   (ooGkClient *pGkClient, struct OOH323CallData *call);
+
+/**
+ * This function is used to handle a received disengage confirm message.
+ * @param pGkClient            Handle to gatekeeper client.
+ * @param pDCF                 Handle to received confirmed message.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooGkClientHandleDisengageConfirm
+   (ooGkClient *pGkClient, H225DisengageConfirm *pDCF);
+
+/**
+ * This function is used to handle an expired registration request timer.
+ * @param pdata     Handle to callback data
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientRRQTimerExpired(void*pdata);
+
+/**
+ * This function is used to handle an expired gatekeeper request timer.
+ * @param pdata     Handle to callback data
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientGRQTimerExpired(void* pdata);
+
+/**
+ * This function is used to handle an expired registration time-to-live timer.
+ * @param pdata     Handle to callback data
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientREGTimerExpired(void *pdata);
+
+/**
+ * This function is used to handle an expired admission request timer.
+ * @param pdata     Handle to callback data
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientARQTimerExpired(void* pdata);
+
+/**
+ * This function is used to clean call related data from gatekeeper client.
+ * @param pGkClient  Handle to the gatekeeper client.
+ * @param call       Handle to the call to be cleaned.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientCleanCall(ooGkClient *pGkClient, struct OOH323CallData *call);
+
+/**
+ * This function is used to handle gatekeeper client failure or gatekeeper 
+ * failure which can be detected by unresponsiveness of gk.
+ * @param pGkClient  Handle to gatekeeper client.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientHandleClientOrGkFailure(ooGkClient *pGkClient);
+
+/**
+ * This function is used to update the registration status of aliases.
+ * @param pGkClient  Handle to the GK client.
+ * @param pAddresses List of newly registered addresses. NULL means all
+ *                   aliases have been successfully registered.
+ * @param registered Indicates whether aliases are registered or unregistered.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGkClientUpdateRegisteredAliases
+   (ooGkClient *pGkClient, H225_SeqOfH225AliasAddress *pAddresses, 
+    OOBOOL registered);
+
+/**
+ * This function is used internally to set Gatekeeper Clients callbacks.
+ * Note: This functionality is not yet fully supported
+ * @param pGkClient  Handle to the GK client.
+ * @param callbacks  Callback structure contatining various gatekeeper client
+ *                   callbacks.
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooGkClientSetCallbacks
+   (ooGkClient *pGkClient, OOGKCLIENTCALLBACKS callbacks);
+/** 
+ * @} 
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GKCLIENT_H */
diff --git a/addons/ooh323c/src/ooLogChan.c b/addons/ooh323c/src/ooLogChan.c
new file mode 100644
index 000000000..86c8844c7
--- /dev/null
+++ b/addons/ooh323c/src/ooLogChan.c
@@ -0,0 +1,372 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooCalls.h"
+#include "ooh323ep.h"
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+OOLogicalChannel* ooAddNewLogicalChannel(OOH323CallData *call, int channelNo, 
+                                         int sessionID, char *dir, 
+                                         ooH323EpCapability *epCap)
+{
+   OOLogicalChannel *pNewChannel=NULL, *pChannel=NULL;
+   OOMediaInfo *pMediaInfo = NULL;
+   OOTRACEDBGC5("Adding new media channel for cap %d dir %s (%s, %s)\n",
+               epCap->cap, dir, call->callType, call->callToken);
+   /* Create a new logical channel entry */
+   pNewChannel = (OOLogicalChannel*)memAlloc(call->pctxt, 
+                                                     sizeof(OOLogicalChannel));
+   if(!pNewChannel)
+   {
+      OOTRACEERR3("ERROR:Memory - ooAddNewLogicalChannel - pNewChannel "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return NULL;
+   }
+   
+   memset(pNewChannel, 0, sizeof(OOLogicalChannel));
+   pNewChannel->channelNo = channelNo;
+   pNewChannel->sessionID = sessionID;
+   pNewChannel->state = OO_LOGICALCHAN_IDLE;
+   pNewChannel->type = epCap->capType;
+   /*   strcpy(pNewChannel->type, type);*/
+   strcpy(pNewChannel->dir, dir);
+
+   pNewChannel->chanCap = epCap;
+   OOTRACEDBGC4("Adding new channel with cap %d (%s, %s)\n", epCap->cap,
+                call->callType, call->callToken); 
+   /* As per standards, media control port should be same for all 
+      proposed channels with same session ID. However, most applications
+      use same media port for transmit and receive of audio streams. Infact,
+      testing of OpenH323 based asterisk assumed that same ports are used. 
+      Hence we first search for existing media ports for same session and use 
+      them. This should take care of all cases.
+   */
+   if(call->mediaInfo)
+   {
+      pMediaInfo = call->mediaInfo;
+      while(pMediaInfo)
+      {
+         if(!strcmp(pMediaInfo->dir, dir) &&
+            (pMediaInfo->cap == epCap->cap))
+         {
+            break;
+         }
+         pMediaInfo = pMediaInfo->next;
+      }
+   }
+    
+   if(pMediaInfo)
+   {
+      OOTRACEDBGC3("Using configured media info (%s, %s)\n", call->callType,
+                   call->callToken);
+      pNewChannel->localRtpPort = pMediaInfo->lMediaPort;
+      pNewChannel->localRtcpPort = pMediaInfo->lMediaCntrlPort;
+      /* If user application has not specified a specific ip and is using 
+         multihomed mode, substitute appropriate ip.
+      */
+      if(!strcmp(pMediaInfo->lMediaIP, "0.0.0.0"))
+         strcpy(pNewChannel->localIP, call->localIP);
+      else
+         strcpy(pNewChannel->localIP, pMediaInfo->lMediaIP);
+   }
+   else{
+      OOTRACEDBGC3("Using default media info (%s, %s)\n", call->callType,
+                   call->callToken);
+      pNewChannel->localRtpPort = ooGetNextPort (OORTP);
+
+      /* Ensures that RTP port is an even one */
+      if((pNewChannel->localRtpPort & 1) == 1)
+        pNewChannel->localRtpPort = ooGetNextPort (OORTP);
+
+      pNewChannel->localRtcpPort = ooGetNextPort (OORTP);
+      strcpy(pNewChannel->localIP, call->localIP);
+   }
+   
+   /* Add new channel to the list */
+   pNewChannel->next = NULL;
+   if(!call->logicalChans) {
+      call->logicalChans = pNewChannel;
+   }
+   else{
+      pChannel = call->logicalChans;
+      while(pChannel->next)  pChannel = pChannel->next;
+      pChannel->next = pNewChannel;
+   }
+   
+   /* increment logical channels */
+   call->noOfLogicalChannels++;
+   OOTRACEINFO3("Created new logical channel entry (%s, %s)\n", call->callType,
+                call->callToken);
+   return pNewChannel;
+}
+
+OOLogicalChannel* ooFindLogicalChannelByLogicalChannelNo(OOH323CallData *call,
+                                                         int ChannelNo)
+{
+   OOLogicalChannel *pLogicalChannel=NULL;
+   if(!call->logicalChans)
+   {
+      OOTRACEERR3("ERROR: No Open LogicalChannels - Failed "
+                  "FindLogicalChannelByChannelNo (%s, %s\n", call->callType,
+                   call->callToken);
+      return NULL;
+   }
+   pLogicalChannel = call->logicalChans;
+   while(pLogicalChannel)
+   {
+      if(pLogicalChannel->channelNo == ChannelNo)
+         break;
+      else
+         pLogicalChannel = pLogicalChannel->next;
+   }
+
+   return pLogicalChannel;
+}
+
+OOLogicalChannel * ooFindLogicalChannelByOLC(OOH323CallData *call, 
+                               H245OpenLogicalChannel *olc)
+{
+   H245DataType * psDataType=NULL;
+   H245H2250LogicalChannelParameters * pslcp=NULL;
+   OOTRACEDBGC4("ooFindLogicalChannel by olc %d (%s, %s)\n", 
+            olc->forwardLogicalChannelNumber, call->callType, call->callToken);
+   if(olc->m.reverseLogicalChannelParametersPresent)
+   {
+      OOTRACEDBGC3("Finding receive channel (%s,%s)\n", call->callType, 
+                                                       call->callToken);
+      psDataType = &olc->reverseLogicalChannelParameters.dataType;
+      /* Only H2250LogicalChannelParameters are supported */
+      if(olc->reverseLogicalChannelParameters.multiplexParameters.t !=
+         T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters){
+         OOTRACEERR4("Error:Invalid olc %d received (%s, %s)\n", 
+           olc->forwardLogicalChannelNumber, call->callType, call->callToken);
+         return NULL;
+      }
+      pslcp = olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;
+
+      return ooFindLogicalChannel(call, pslcp->sessionID, "receive", psDataType);
+   }
+   else{
+      OOTRACEDBGC3("Finding transmit channel (%s, %s)\n", call->callType, 
+                                                           call->callToken);
+      psDataType = &olc->forwardLogicalChannelParameters.dataType;
+      /* Only H2250LogicalChannelParameters are supported */
+      if(olc->forwardLogicalChannelParameters.multiplexParameters.t != 
+         T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
+      {
+         OOTRACEERR4("Error:Invalid olc %d received (%s, %s)\n", 
+           olc->forwardLogicalChannelNumber, call->callType, call->callToken);
+         return NULL;
+      }
+      pslcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;
+      return ooFindLogicalChannel(call, pslcp->sessionID, "transmit", psDataType);
+   }
+}
+
+OOLogicalChannel * ooFindLogicalChannel(OOH323CallData *call, int sessionID, 
+                                        char *dir, H245DataType * dataType)
+{
+   OOLogicalChannel * pChannel = NULL;
+   pChannel = call->logicalChans;
+   while(pChannel)
+   {
+      OOTRACEDBGC3("ooFindLogicalChannel, checking channel: %d:%s\n",
+                    pChannel->sessionID, pChannel->dir);
+      if(pChannel->sessionID == sessionID)
+      {
+         if(!strcmp(pChannel->dir, dir))
+         {
+            OOTRACEDBGC3("ooFindLogicalChannel, comparing channel: %d:%s\n",
+                          pChannel->channelNo, pChannel->dir);
+            if(!strcmp(dir, "receive"))
+            {
+               if(ooCapabilityCheckCompatibility(call, pChannel->chanCap,
+                                                 dataType, OORX)) {
+                  return pChannel;
+               }
+            }
+            else if(!strcmp(dir, "transmit"))
+            {
+               if(ooCapabilityCheckCompatibility(call, pChannel->chanCap,
+                                                 dataType, OOTX)) {
+                  return pChannel;
+               }
+            }
+         }
+      }
+      pChannel = pChannel->next;
+   }
+   return NULL;
+}
+
+/* This function is used to get a logical channel with a particular session ID */
+OOLogicalChannel* ooGetLogicalChannel
+   (OOH323CallData *call, int sessionID, char *dir)
+{
+   OOLogicalChannel * pChannel = NULL;
+   pChannel = call->logicalChans;
+   while(pChannel)
+   {
+      if(pChannel->sessionID == sessionID && !strcmp(pChannel->dir, dir))
+         return pChannel;
+      else
+         pChannel = pChannel->next;
+   }
+   return NULL;
+}
+
+int ooClearAllLogicalChannels(OOH323CallData *call)
+{
+   OOLogicalChannel * temp = NULL, *prev = NULL;
+
+   OOTRACEINFO3("Clearing all logical channels (%s, %s)\n", call->callType,
+                 call->callToken);
+   
+   temp = call->logicalChans;
+   while(temp)
+   {
+      prev = temp;
+      temp = temp->next;
+      ooClearLogicalChannel(call, prev->channelNo);/* TODO: efficiency - This causes re-search 
+                                                      of of logical channel in the list. Can be
+                                                      easily improved.*/
+   }
+   call->logicalChans = NULL;
+   return OO_OK;
+}
+
+int ooClearLogicalChannel(OOH323CallData *call, int channelNo)
+{
+
+   OOLogicalChannel *pLogicalChannel = NULL;
+   ooH323EpCapability *epCap=NULL;
+
+   OOTRACEDBGC4("Clearing logical channel number %d. (%s, %s)\n", channelNo,
+                 call->callType, call->callToken);
+
+   pLogicalChannel = ooFindLogicalChannelByLogicalChannelNo(call,channelNo);
+   if(!pLogicalChannel)
+   {
+      OOTRACEWARN4("Logical Channel %d doesn't exist, in clearLogicalChannel."
+                   " (%s, %s)\n",
+                  channelNo, call->callType, call->callToken);
+      return OO_OK;
+   }
+
+   epCap = (ooH323EpCapability*) pLogicalChannel->chanCap;
+   if(!strcmp(pLogicalChannel->dir, "receive"))
+   {
+      if(epCap->stopReceiveChannel)
+      {
+         epCap->stopReceiveChannel(call, pLogicalChannel);
+         OOTRACEINFO4("Stopped Receive channel %d (%s, %s)\n", 
+                                 channelNo, call->callType, call->callToken);
+      }
+      else{
+         OOTRACEERR4("ERROR:No callback registered for stopReceiveChannel %d "
+                     "(%s, %s)\n", channelNo, call->callType, call->callToken);
+      }
+   }
+   else
+   {
+      if(pLogicalChannel->state == OO_LOGICALCHAN_ESTABLISHED)
+      {
+         if(epCap->stopTransmitChannel)
+         {
+            epCap->stopTransmitChannel(call, pLogicalChannel);
+            OOTRACEINFO4("Stopped Transmit channel %d (%s, %s)\n", 
+                          channelNo, call->callType, call->callToken);
+         }
+         else{
+            OOTRACEERR4("ERROR:No callback registered for stopTransmitChannel"
+                        " %d (%s, %s)\n", channelNo, call->callType, 
+                        call->callToken);
+         }
+      }
+   }
+   ooRemoveLogicalChannel(call, channelNo);/* TODO: efficiency - This causes re-search of
+                                                    of logical channel in the list. Can be
+                                                    easily improved.*/
+   return OO_OK;
+}
+
+int ooRemoveLogicalChannel(OOH323CallData *call, int ChannelNo)
+{
+   OOLogicalChannel * temp = NULL, *prev=NULL; 
+   if(!call->logicalChans)
+   {
+      OOTRACEERR4("ERROR:Remove Logical Channel - Channel %d not found "
+                  "Empty channel List(%s, %s)\n", ChannelNo, call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+
+   temp = call->logicalChans;
+   while(temp)
+   {
+      if(temp->channelNo == ChannelNo)
+      {
+         if(!prev)   call->logicalChans = temp->next;
+         else   prev->next = temp->next;
+         memFreePtr(call->pctxt, temp->chanCap);
+         memFreePtr(call->pctxt, temp);
+         OOTRACEDBGC4("Removed logical channel %d (%s, %s)\n", ChannelNo,
+                       call->callType, call->callToken);
+         call->noOfLogicalChannels--;
+         return OO_OK;
+      }
+      prev = temp;
+      temp = temp->next;
+   }
+   
+   OOTRACEERR4("ERROR:Remove Logical Channel - Channel %d not found "
+                  "(%s, %s)\n", ChannelNo, call->callType, call->callToken);
+   return OO_FAILED;
+}
+
+/* 
+Change the state of the channel as established and close all other 
+channels with same session IDs. This is useful for handling fastStart, 
+as the endpoint can open multiple logical channels for same sessionID.
+Once the remote endpoint confirms it's selection, all other channels for 
+the same sessionID must be closed.
+*/
+int ooOnLogicalChannelEstablished
+   (OOH323CallData *call, OOLogicalChannel * pChannel)
+{
+   OOLogicalChannel * temp = NULL, *prev=NULL; 
+   OOTRACEDBGC3("In ooOnLogicalChannelEstablished (%s, %s)\n",
+                call->callType, call->callToken);
+   pChannel->state = OO_LOGICALCHAN_ESTABLISHED;
+   temp = call->logicalChans;
+   while(temp)
+   {
+      if(temp->channelNo != pChannel->channelNo &&
+         temp->sessionID == pChannel->sessionID &&
+         !strcmp(temp->dir, pChannel->dir)        )
+      {
+         prev = temp;
+         temp = temp->next;
+         ooClearLogicalChannel(call, prev->channelNo);
+      }
+      else
+         temp = temp->next;
+   }
+   return OO_OK;
+}
+
diff --git a/addons/ooh323c/src/ooLogChan.h b/addons/ooh323c/src/ooLogChan.h
new file mode 100644
index 000000000..eeb0f772e
--- /dev/null
+++ b/addons/ooh323c/src/ooLogChan.h
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file ooLogChan.h 
+ * This file contains structures and functions for maintaining information
+ * on logical channels within the stack.
+ */
+#ifndef _OOLOGCHAN_H_
+#define _OOLOGCHAN_H_
+
+#include "ootypes.h"
+#include "ooCapability.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup logchan H.245 logical channel management
+ * @{
+ */
+struct ooH323EpCapability;
+struct OOH323CallData;
+
+/** 
+ * Logical channel states.
+ */
+typedef enum {
+   OO_LOGICAL_CHAN_UNKNOWN, 
+   OO_LOGICALCHAN_IDLE, 
+   OO_LOGICALCHAN_PROPOSED, 
+   OO_LOGICALCHAN_ESTABLISHED
+} OOLogicalChannelState;
+
+/**
+ * Structure to store information on logical channels for a call.
+ */
+typedef struct OOLogicalChannel {
+   int  channelNo;
+   int  sessionID;
+   enum OOCapType type;
+   char dir[10];  /* receive/transmit */
+   char remoteIP[20];
+   int  remoteMediaPort;
+   int  remoteMediaControlPort;
+   int  localRtpPort;
+   int  localRtcpPort;
+   char localIP[20];
+   OOLogicalChannelState state;         
+   struct ooH323EpCapability *chanCap;
+   struct OOLogicalChannel *next;
+} OOLogicalChannel;
+
+#define ooLogicalChannel OOLogicalChannel
+
+/**
+ * This function is used to add a new logical channel entry into the list
+ * of currently active logical channels.
+ * @param call      Pointer to the call for which new logical channel 
+ *                  entry has to be created.
+ * @param channelNo Channel number for the new channel entry.
+ * @param sessionID Session identifier for the new channel.
+ * @param dir       Direction of the channel(transmit/receive)
+ * @param epCap     Capability to be used for the new channel.
+ *
+ * @return          Pointer to logical channel, on success. NULL, on failure
+ */
+EXTERN ooLogicalChannel* ooAddNewLogicalChannel
+   (struct OOH323CallData *call, int channelNo, int sessionID, 
+    char *dir, ooH323EpCapability *epCap);
+
+/**
+ * This function is used to find a logical channel using the logical 
+ * channel number as a key.
+ * @param call          Pointer to the call for which logical channel is 
+ *                      required.
+ * @param channelNo     Forward Logical Channel number for the logical channel
+ *
+ * @return              Pointer to the logical channel if found, NULL 
+ *                      otherwise.   
+ */
+EXTERN ooLogicalChannel* ooFindLogicalChannelByLogicalChannelNo
+(struct OOH323CallData *call, int channelNo);
+
+/**
+ * This function is called when a new logical channel is established. It is 
+ * particularly useful in case of faststart. When the remote endpoint selects 
+ * one of the proposed alternatives, other channels for the same session type 
+ * need to be closed. This function is used for that.
+ *
+ * @param call      Handle to the call which owns the logical channel.
+ * @param pChannel  Handle to the newly established logical channel.
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnLogicalChannelEstablished
+(struct OOH323CallData *call, OOLogicalChannel * pChannel);
+
+/**
+ * This function is used to retrieve a logical channel with a particular 
+ * sessionID. Note that there can be two entries of logical channel, one in 
+ * each direction. This function will return the first channel which has the 
+ * same session ID.
+ * @param call      Handle to the call which owns the channels to be searched.
+ * @param sessionID Session id of the session which is to be searched for.
+ * @param dir       Direction of the channel.(transmit/receive)
+ *
+ * @return          Returns a pointer to the logical channel if found, NULL 
+ *                  otherwise.
+ */
+EXTERN ooLogicalChannel* ooGetLogicalChannel
+(struct OOH323CallData *call, int sessionID, char *dir);
+
+/**
+ * This function is used to remove a logical channel from the list of 
+ * channels within the call structure.
+ * @param call              Pointer to the call from which logical channel has 
+ *                          to be removed.
+ * @param ChannelNo         Forward logical channel number of the channel to be
+ *                          removed.
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooRemoveLogicalChannel (struct OOH323CallData *call, int ChannelNo);
+
+/**
+ * This function is used to cleanup a logical channel. It first stops media if
+ * it is still active and then removes the channel from the list, freeing up 
+ * all the associated memory.
+ * @param call       Handle to the call which owns the logical channel.
+ * @param channelNo  Channel number identifying the channel.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooClearLogicalChannel (struct OOH323CallData *call, int channelNo);
+
+/**
+ * This function is used to cleanup all the logical channels associated with 
+ * the call.
+ * @param call      Handle to the call which owns the channels.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooClearAllLogicalChannels (struct OOH323CallData *call);
+
+/**
+ * This function is used to find a logical channel from a received
+ * H.245 Open Logical Channel (OLC) message.
+ * @param call     Handle to the related call.
+ * @param olc      Handle to the received OLC.
+ *
+ * @return         Returns the corresponding logical channel if found,
+ *                 else returns NULL.
+ */
+EXTERN OOLogicalChannel * ooFindLogicalChannelByOLC
+(struct OOH323CallData *call, H245OpenLogicalChannel *olc);
+
+/**
+ * This function is used to find a logical channel based on session Id,
+ * direction of channel and datatype.
+ * @param call       Handle to the call
+ * @param sessionID  Session ID for the channel to be searched.
+ * @param dir        Direction of the channel wrt local endpoint.
+ *                   (transmit/receive)
+ * @param dataType   Handle to the data type for the channel.
+ *
+ * @return           Logical channel, if found, NULL otherwise.
+ */
+EXTERN OOLogicalChannel * ooFindLogicalChannel
+(struct OOH323CallData* call, int sessionID, char *dir, H245DataType* dataType);
+
+/** 
+ * @} 
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/ooSocket.c b/addons/ooh323c/src/ooSocket.c
new file mode 100644
index 000000000..181cf6792
--- /dev/null
+++ b/addons/ooh323c/src/ooSocket.c
@@ -0,0 +1,723 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooSocket.h"
+#include "ootrace.h"
+#if defined(_WIN32_WCE)
+static int inited = 0;
+#define SEND_FLAGS     0
+#define SHUTDOWN_FLAGS 0
+#elif defined (_WIN32)
+static LPFN_SEND send;
+static LPFN_SOCKET socket;
+static LPFN_SETSOCKOPT setsockopt;
+static LPFN_BIND bind;
+static LPFN_HTONL htonl;
+static LPFN_HTONS htons;
+static LPFN_CONNECT connect;
+static LPFN_INET_ADDR inet_addr;
+static LPFN_LISTEN listen;
+static LPFN_ACCEPT accept;
+static LPFN_NTOHL ntohl;
+static LPFN_NTOHS ntohs;
+static LPFN_RECV recv;
+static LPFN_SHUTDOWN shutdown;
+
+
+static LPFN_IOCTLSOCKET ioctlsocket;
+static LPFN_SENDTO sendto;
+static LPFN_INET_NTOA inet_ntoa;
+static LPFN_RECVFROM recvfrom;
+static LPFN_SELECT select;
+static LPFN_GETHOSTNAME gethostname;
+static LPFN_GETHOSTBYNAME gethostbyname;
+static LPFN_WSAGETLASTERROR  WSAGetLastError;
+static LPFN_WSACLEANUP WSACleanup;
+static LPFN_CLOSESOCKET closesocket;
+static LPFN_GETSOCKNAME getsockname;
+static HMODULE ws32 = 0;
+#define SEND_FLAGS     0
+#define SHUTDOWN_FLAGS SD_BOTH
+#else
+#define SEND_FLAGS     0
+#define SHUTDOWN_FLAGS SHUT_RDWR
+#define closesocket close
+#endif
+
+
+
+int ooSocketsInit ()
+{
+#if defined(_WIN32_WCE)
+   WORD wVersionRequested;
+   WSADATA wsaData;
+   int err;
+
+   if (inited) return ASN_OK; 
+
+   wVersionRequested = MAKEWORD( 1, 1 );
+    
+   err = WSAStartup (wVersionRequested, &wsaData);
+   if ( err != 0 ) {
+      /* Tell the user that we could not find a usable */
+      /* WinSock DLL.   */
+      return ASN_E_NOTINIT;
+   }
+   inited = 1;
+
+#elif defined (_WIN32)
+   LPFN_WSASTARTUP wsaStartup = NULL;
+   WSADATA wsaData;
+
+   if (ws32 != 0) return ASN_OK;
+
+//   ws32 = LoadLibrary ("WSOCK32.DLL");
+  ws32 = LoadLibrary ("WS2_32.DLL");
+   if (ws32 == NULL) return ASN_E_NOTINIT;
+   
+   wsaStartup = (LPFN_WSASTARTUP) GetProcAddress (ws32, "WSAStartup");
+   if (wsaStartup == NULL) return ASN_E_NOTINIT;
+   
+   send = (LPFN_SEND) GetProcAddress (ws32, "send");
+   if (send == NULL) return ASN_E_NOTINIT;
+   
+   socket = (LPFN_SOCKET) GetProcAddress (ws32, "socket");
+   if (socket == NULL) return ASN_E_NOTINIT;
+   
+   setsockopt = (LPFN_SETSOCKOPT) GetProcAddress (ws32, "setsockopt");
+   if (setsockopt == NULL) return ASN_E_NOTINIT;
+   
+   bind = (LPFN_BIND) GetProcAddress (ws32, "bind");
+   if (bind == NULL) return ASN_E_NOTINIT;
+   
+   htonl = (LPFN_HTONL) GetProcAddress (ws32, "htonl");
+   if (htonl == NULL) return ASN_E_NOTINIT;
+   
+   htons = (LPFN_HTONS) GetProcAddress (ws32, "htons");
+   if (htons == NULL) return ASN_E_NOTINIT;
+   
+   connect = (LPFN_CONNECT) GetProcAddress (ws32, "connect");
+   if (connect == NULL) return ASN_E_NOTINIT;
+   
+   listen = (LPFN_LISTEN) GetProcAddress (ws32, "listen");
+   if (listen == NULL) return ASN_E_NOTINIT;
+   
+   accept = (LPFN_ACCEPT) GetProcAddress (ws32, "accept");
+   if (accept == NULL) return ASN_E_NOTINIT;
+   
+   inet_addr = (LPFN_INET_ADDR) GetProcAddress (ws32, "inet_addr");
+   if (inet_addr == NULL) return ASN_E_NOTINIT;
+   
+   ntohl = (LPFN_NTOHL) GetProcAddress (ws32, "ntohl");
+   if (ntohl == NULL) return ASN_E_NOTINIT;
+   
+   ntohs = (LPFN_NTOHS) GetProcAddress (ws32, "ntohs");
+   if (ntohs == NULL) return ASN_E_NOTINIT;
+   
+   recv = (LPFN_RECV) GetProcAddress (ws32, "recv");
+   if (recv == NULL) return ASN_E_NOTINIT;
+   
+   shutdown = (LPFN_SHUTDOWN) GetProcAddress (ws32, "shutdown");
+   if (shutdown == NULL) return ASN_E_NOTINIT;
+   
+   closesocket = (LPFN_CLOSESOCKET) GetProcAddress (ws32, "closesocket");
+   if (closesocket == NULL) return ASN_E_NOTINIT;
+
+   getsockname = (LPFN_GETSOCKNAME) GetProcAddress (ws32, "getsockname");
+   if (getsockname == NULL) return ASN_E_NOTINIT;
+   
+   ioctlsocket = (LPFN_IOCTLSOCKET) GetProcAddress(ws32, "ioctlsocket");
+   if(ioctlsocket == NULL) return ASN_E_NOTINIT;
+
+   sendto = (LPFN_SENDTO) GetProcAddress (ws32, "sendto");
+   if (sendto == NULL) return ASN_E_NOTINIT;
+
+   inet_ntoa = (LPFN_INET_NTOA) GetProcAddress (ws32, "inet_ntoa");
+   if (inet_ntoa == NULL) return ASN_E_NOTINIT;
+
+   recvfrom = (LPFN_RECVFROM) GetProcAddress (ws32, "recvfrom");
+   if (recvfrom == NULL) return ASN_E_NOTINIT;
+
+   select = (LPFN_SELECT) GetProcAddress (ws32, "select");
+   if (select == NULL) return ASN_E_NOTINIT;
+
+   gethostname = (LPFN_GETHOSTNAME) GetProcAddress (ws32, "gethostname");
+   if (gethostname == NULL) return ASN_E_NOTINIT;
+
+   gethostbyname = (LPFN_GETHOSTBYNAME) GetProcAddress (ws32, "gethostbyname");
+   if (gethostbyname == NULL) return ASN_E_NOTINIT;
+   
+   WSAGetLastError = (LPFN_WSAGETLASTERROR) GetProcAddress (ws32, 
+                                                           "WSAGetLastError");
+   if (WSAGetLastError == NULL) return ASN_E_NOTINIT;
+
+   WSACleanup = (LPFN_WSACLEANUP) GetProcAddress (ws32, "WSACleanup");
+   if (WSACleanup == NULL) return ASN_E_NOTINIT;
+   
+      
+   if (wsaStartup (MAKEWORD(1, 1), &wsaData) == -1) return ASN_E_NOTINIT;
+#endif
+   return ASN_OK;
+}
+
+#if defined (_WIN32) || \
+defined(_HP_UX) || defined(__hpux) || defined(_HPUX_SOURCE)
+typedef int OOSOCKLEN;
+#else
+typedef size_t OOSOCKLEN;
+#endif
+
+int ooSocketCreate (OOSOCKET* psocket) 
+{
+   int on;
+
+   struct linger linger;
+   OOSOCKET sock = socket (AF_INET,
+                             SOCK_STREAM,
+                             0);
+  
+   if (sock == OOSOCKET_INVALID){
+      OOTRACEERR1("Error:Failed to create TCP socket\n");
+      return ASN_E_INVSOCKET;
+   }
+
+   on = 1;
+   if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, 
+                   (const char* ) &on, sizeof (on)) == -1)
+   {
+      OOTRACEERR1("Error:Failed to set socket option SO_REUSEADDR\n");
+      return ASN_E_INVSOCKET;
+   }
+   linger.l_onoff = 1;
+   linger.l_linger = 0;
+   if (setsockopt (sock, SOL_SOCKET, SO_LINGER, 
+                   (const char* ) &linger, sizeof (linger)) == -1)
+   {
+      OOTRACEERR1("Error:Failed to set socket option linger\n");
+      return ASN_E_INVSOCKET;
+   }
+   *psocket = sock;
+   return ASN_OK;
+}
+
+int ooSocketCreateUDP (OOSOCKET* psocket) 
+{
+   int on;
+   struct linger linger;
+
+   OOSOCKET sock = socket (AF_INET,
+                             SOCK_DGRAM,
+                             0);
+
+   if (sock == OOSOCKET_INVALID){
+      OOTRACEERR1("Error:Failed to create UDP socket\n");
+      return ASN_E_INVSOCKET;
+   }
+
+   on = 1;
+   if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, 
+                   (const char* ) &on, sizeof (on)) == -1)
+   {
+      OOTRACEERR1("Error:Failed to set socket option SO_REUSEADDR\n");
+      return ASN_E_INVSOCKET;
+   }
+   linger.l_onoff = 1;
+   linger.l_linger = 0;
+   /*if (setsockopt (sock, SOL_SOCKET, SO_LINGER, 
+                 (const char* ) &linger, sizeof (linger)) == -1)
+      return ASN_E_INVSOCKET;
+   */
+   *psocket = sock;
+   return ASN_OK;
+}
+
+int ooSocketClose (OOSOCKET socket)
+{
+   shutdown (socket, SHUTDOWN_FLAGS);
+   if (closesocket (socket) == -1)
+      return ASN_E_INVSOCKET;
+   return ASN_OK;
+}
+
+int ooSocketBind (OOSOCKET socket, OOIPADDR addr, int port) 
+{
+   struct sockaddr_in m_addr;
+
+   if (socket == OOSOCKET_INVALID)
+   { 
+      OOTRACEERR1("Error:Invalid socket passed to bind\n");
+      return ASN_E_INVSOCKET;
+   }
+
+   memset (&m_addr, 0, sizeof (m_addr));
+   m_addr.sin_family = AF_INET;
+   m_addr.sin_addr.s_addr = (addr == 0) ? INADDR_ANY : htonl (addr);
+   m_addr.sin_port = htons ((unsigned short)port);
+
+   if (bind (socket, (struct sockaddr *) (void*) &m_addr,
+                     sizeof (m_addr)) == -1)
+   {
+      perror ("bind");
+      OOTRACEERR1("Error:Bind failed\n");
+      return ASN_E_INVSOCKET;
+   }
+
+   return ASN_OK;
+}
+
+
+int ooSocketGetSockName(OOSOCKET socket, struct sockaddr_in *name, int *size)
+{
+   int ret;
+   ret = getsockname(socket, (struct sockaddr*)name, size);
+   if(ret == 0)
+      return ASN_OK;
+   else{
+      OOTRACEERR1("Error:ooSocketGetSockName - getsockname\n");
+      return ASN_E_INVSOCKET;
+   }
+}
+
+int ooSocketGetIpAndPort(OOSOCKET socket, char *ip, int len, int *port)
+{
+   int ret=ASN_OK, size;
+   struct sockaddr_in addr;
+   char *host=NULL;
+
+   size = sizeof(addr);
+
+   ret = ooSocketGetSockName(socket, &addr, &size);
+   if(ret != 0)
+      return ASN_E_INVSOCKET;
+
+   host = inet_ntoa(addr.sin_addr);
+
+   if(host && strlen(host) < (unsigned)len)
+      strcpy(ip, host);   
+   else{
+     OOTRACEERR1("Error:Insufficient buffer for ip address - "
+                 "ooSocketGetIpAndPort\n");
+      return -1;
+   }
+   
+   *port = addr.sin_port;
+
+   return ASN_OK;
+}
+
+int ooSocketListen (OOSOCKET socket, int maxConnection) 
+{
+   if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET;
+
+   if (listen (socket, maxConnection) == -1)
+      return ASN_E_INVSOCKET;
+
+   return ASN_OK;
+}
+
+int ooSocketAccept (OOSOCKET socket, OOSOCKET *pNewSocket, 
+                    OOIPADDR* destAddr, int* destPort) 
+{
+   struct sockaddr_in m_addr;
+   OOSOCKLEN addr_length = sizeof (m_addr);
+
+   if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET;
+   if (pNewSocket == 0) return ASN_E_INVPARAM;
+
+   *pNewSocket = accept (socket, (struct sockaddr *) (void*) &m_addr, 
+                         (socklen_t *) &addr_length);
+   if (*pNewSocket <= 0) return ASN_E_INVSOCKET;
+
+   if (destAddr != 0) 
+      *destAddr = ntohl (m_addr.sin_addr.s_addr);
+   if (destPort != 0)
+      *destPort = ntohs (m_addr.sin_port);
+
+   return ASN_OK;
+}
+
+int ooSocketConnect (OOSOCKET socket, const char* host, int port) 
+{
+   struct sockaddr_in m_addr;
+
+   if (socket == OOSOCKET_INVALID)
+   { 
+      return ASN_E_INVSOCKET;
+   }
+   
+   memset (&m_addr, 0, sizeof (m_addr));
+
+   m_addr.sin_family = AF_INET;
+   m_addr.sin_port = htons ((unsigned short)port);
+   m_addr.sin_addr.s_addr = inet_addr (host);
+
+   if (connect (socket, (struct sockaddr *) (void*) &m_addr, 
+                sizeof (struct sockaddr_in)) == -1)
+   {
+      return ASN_E_INVSOCKET;
+   }
+   return ASN_OK;
+}
+/*
+// **Need to add check whether complete data was sent by checking the return
+// **value of send and if complete data is not sent then add mechanism to 
+// **send remaining bytes. This will make ooSocketSend call atomic.
+*/
+int ooSocketSend (OOSOCKET socket, const ASN1OCTET* pdata, ASN1UINT size)
+{
+   if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET;
+   
+   if (send (socket, (const char*) pdata, size, SEND_FLAGS) == -1)
+      return ASN_E_INVSOCKET;
+   return ASN_OK;
+}
+
+int ooSocketSendTo(OOSOCKET socket, const ASN1OCTET* pdata, ASN1UINT size,
+                     const char* host, int port)
+{
+   struct sockaddr_in m_addr;
+   if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET;
+   
+   memset (&m_addr, 0, sizeof (m_addr));
+
+   m_addr.sin_family = AF_INET;
+   m_addr.sin_port = htons ((unsigned short)port);
+   m_addr.sin_addr.s_addr = inet_addr (host);
+   if (sendto (socket, (const char*) pdata, size, SEND_FLAGS, 
+                                    (const struct sockaddr*)&m_addr, 
+                                    sizeof(m_addr)) == -1)
+      return ASN_E_INVSOCKET;
+   return ASN_OK;
+}
+
+int ooSocketRecvPeek(OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize)
+{
+   int len;
+   int flags = MSG_PEEK;
+
+   if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET;
+
+   if ((len = recv (socket, (char*) pbuf, bufsize, flags)) == -1)
+      return ASN_E_INVSOCKET;
+   return len;
+}
+
+int ooSocketRecv (OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize)
+{
+   int len;
+   if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET;
+
+   if ((len = recv (socket, (char*) pbuf, bufsize, 0)) == -1)
+      return ASN_E_INVSOCKET;
+   return len;
+}
+
+int ooSocketRecvFrom (OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize,
+                      char* remotehost, ASN1UINT hostBufLen, int * remoteport)
+{
+   struct sockaddr_in m_addr;
+   int len, addrlen;
+   char * host=NULL;
+   if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET;
+   addrlen = sizeof(m_addr);
+
+   memset (&m_addr, 0, sizeof (m_addr));
+      
+   if ((len = recvfrom (socket, (char*) pbuf, bufsize, 0, 
+                        (struct sockaddr*)&m_addr, &addrlen)) == -1)
+      return ASN_E_INVSOCKET;
+
+   if(remoteport)
+      *remoteport = ntohs(m_addr.sin_port);
+   if(remotehost)
+   {
+      host = inet_ntoa(m_addr.sin_addr);
+      if(strlen(host) < (hostBufLen-1))
+         strcpy(remotehost, host);
+      else
+         return -1;
+   }
+   return len;
+}
+
+int ooSocketSelect(int nfds, fd_set *readfds, fd_set *writefds, 
+                     fd_set *exceptfds, struct timeval * timeout)
+{
+   int ret;   
+#if defined (_WIN32)
+  ret = select(nfds, readfds, writefds, exceptfds, 
+             (const struct timeval *) timeout);
+#else
+   ret = select(nfds, readfds, writefds, exceptfds, timeout);
+#endif
+   return ret;
+}
+
+int ooGetLocalIPAddress(char * pIPAddrs)
+{
+   int ret;
+   struct hostent *phost;
+   struct in_addr addr;
+   char hostname[100];
+
+   if(pIPAddrs == NULL)
+      return -1; /* Need to find suitable return value */
+   ret = gethostname(hostname, 100);
+   if(ret == 0)
+   {
+      phost = gethostbyname(hostname);
+      if(phost == NULL)
+         return -1; /* Need to define a return value if made part of rtsrc */
+      memcpy(&addr, phost->h_addr_list[0], sizeof(struct in_addr));
+      strcpy(pIPAddrs, inet_ntoa(addr));
+     
+   }
+   else{
+      return -1;
+   }
+   return ASN_OK;
+}
+
+int ooSocketStrToAddr (const char* pIPAddrStr, OOIPADDR* pIPAddr) 
+{
+   int b1, b2, b3, b4;
+   int rv = sscanf (pIPAddrStr, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
+   if (rv != 4 ||
+      (b1 < 0 || b1 > 256) || (b2 < 0 || b2 > 256) ||
+      (b3 < 0 || b3 > 256) || (b4 < 0 || b4 > 256))
+      return ASN_E_INVPARAM;
+   *pIPAddr = ((b1 & 0xFF) << 24) | ((b2 & 0xFF) << 16) | 
+              ((b3 & 0xFF) << 8) | (b4 & 0xFF);
+   return ASN_OK;
+}
+
+int ooSocketConvertIpToNwAddr(char *inetIp, char *netIp)
+{
+
+   struct sockaddr_in sin = {0};
+#ifdef _WIN32
+   sin.sin_addr.s_addr = inet_addr(inetIp);
+   if(sin.sin_addr.s_addr == INADDR_NONE)
+   {
+      OOTRACEERR1("Error:Failed to convert address\n");
+      return -1;
+   }
+#else
+   if(!inet_aton(inetIp, &sin.sin_addr))
+   {
+      OOTRACEERR1("Error:Failed to convert address\n");
+      return -1;
+   }
+  
+#endif
+   
+   memcpy(netIp, (char*)&sin.sin_addr.s_addr, sizeof(unsigned long));
+   return ASN_OK;
+}
+
+int ooSocketAddrToStr (OOIPADDR ipAddr, char* pbuf, int bufsize)
+{
+   char buf1[5], buf2[5], buf3[5], buf4[5];
+   int cnt = 0;
+
+   if (bufsize < 8) 
+      return ASN_E_BUFOVFLW;
+
+   cnt += sprintf (buf1, "%lu", (ipAddr >> 24) & 0xFF);
+   cnt += sprintf (buf2, "%lu", (ipAddr >> 16) & 0xFF);
+   cnt += sprintf (buf3, "%lu", (ipAddr >> 8) & 0xFF);
+   cnt += sprintf (buf4, "%lu", ipAddr & 0xFF);
+   if (bufsize < cnt + 4)
+      return ASN_E_BUFOVFLW;
+   sprintf (pbuf, "%s.%s.%s.%s", buf1, buf2, buf3, buf4);
+   return ASN_OK;
+}
+
+int ooSocketsCleanup (void)
+{
+#ifdef _WIN32
+   int ret = WSACleanup();
+   if(ret == 0)
+      return ASN_OK;
+   else
+      return ret;
+#endif
+   return ASN_OK;
+}
+
+long ooSocketHTONL(long val)
+{
+   return htonl(val);
+}
+
+short ooSocketHTONS(short val)
+{
+   return htons(val);
+}
+
+#ifndef _WIN32
+int ooSocketGetInterfaceList(OOCTXT *pctxt, OOInterface **ifList)
+{
+   OOSOCKET sock;
+   struct ifconf ifc;
+   int ifNum;
+   OOInterface *pIf=NULL;
+
+   OOTRACEDBGA1("Retrieving local interfaces\n");
+   if(ooSocketCreateUDP(&sock)!= ASN_OK)
+   {
+      OOTRACEERR1("Error:Failed to create udp socket - "
+                  "ooSocketGetInterfaceList\n");   
+      return -1;
+   }
+#ifdef SIOCGIFNUM
+   if(ioctl(sock, SIOCGIFNUM, &ifNum) >= 0)
+   {
+      OOTRACEERR1("Error: ioctl for ifNum failed\n");
+      return -1;
+   }
+#else
+   ifNum = 50;
+#endif
+ 
+   ifc.ifc_len = ifNum * sizeof(struct ifreq);
+   ifc.ifc_req = (struct ifreq *)memAlloc(pctxt, ifNum *sizeof(struct ifreq));
+   if(!ifc.ifc_req)
+   {
+      OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - ifc.ifc_req\n");
+      return -1;
+   }
+
+   if (ioctl(sock, SIOCGIFCONF, &ifc) >= 0) {
+      void * ifEndList = (char *)ifc.ifc_req + ifc.ifc_len;
+      struct ifreq *ifName;
+      struct ifreq ifReq;
+      int flags;
+      for (ifName = ifc.ifc_req; (void*)ifName < ifEndList; ifName++) {
+         char *pName=NULL;
+         char addr[50];
+#ifdef ifr_netmask
+	 char mask[50];
+#endif
+         
+         pIf = (struct OOInterface*)memAlloc(pctxt, sizeof(struct OOInterface));
+         pName = (char*)memAlloc(pctxt, strlen(ifName->ifr_name)+1);
+         if(!pIf)
+         {
+            OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
+                        "pIf/pName\n");
+            return -1;
+         }
+         OOTRACEDBGA2("\tInterface name: %s\n", ifName->ifr_name);
+         
+         
+         strcpy(ifReq.ifr_name, ifName->ifr_name);
+         strcpy(pName, ifName->ifr_name);
+         pIf->name = pName;
+
+         /* Check whether the interface is up*/
+         if (ioctl(sock, SIOCGIFFLAGS, &ifReq) < 0) {
+            OOTRACEERR2("Error:Unable to determine status of interface %s\n", 
+                        pName);
+            memFreePtr(pctxt, pIf->name);
+            memFreePtr(pctxt, pIf);
+            continue;
+         }
+         flags = ifReq.ifr_flags;
+         if (!(flags & IFF_UP)) {
+            OOTRACEWARN2("Warn:Interface %s is not up\n", pName);
+            memFreePtr(pctxt, pIf->name);
+            memFreePtr(pctxt, pIf);
+            continue;
+         }
+
+         /* Retrieve interface address */
+         if (ioctl(sock, SIOCGIFADDR, &ifReq) < 0) 
+         {
+            OOTRACEWARN2("Warn:Unable to determine address of interface %s\n", 
+                          pName);
+            memFreePtr(pctxt, pIf->name);
+            memFreePtr(pctxt, pIf);
+            continue;
+         }
+         strcpy(addr, inet_ntoa(((struct sockaddr_in*)&ifReq.ifr_addr)->sin_addr));
+         OOTRACEDBGA2("\tIP address is %s\n", addr);
+         pIf->addr = (char*)memAlloc(pctxt, strlen(addr)+1);
+         if(!pIf->addr)
+         {
+            OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
+                        "pIf->addr\n");
+            memFreePtr(pctxt, pIf->name);
+            memFreePtr(pctxt, pIf);
+            return -1;
+         }
+         strcpy(pIf->addr, addr);
+         
+#ifdef ifr_netmask
+         if (ioctl(sock, SIOCGIFNETMASK, &ifReq) < 0) 
+         {
+            OOTRACEWARN2("Warn:Unable to determine mask for interface %s\n", 
+                          pName);
+            memFreePtr(pctxt, pIf->name);
+            memFreePtr(pctxt, pIf->addr);
+            memFreePtr(pctxt, pIf);
+            continue;
+         }
+         strcpy(mask, inet_ntoa(((struct sockaddr_in *)&ifReq.ifr_netmask)->sin_addr));
+         OOTRACEDBGA2("\tMask is %s\n", mask);
+         pIf->mask = (char*)memAlloc(pctxt, strlen(mask)+1);
+         if(!pIf->mask)
+         {
+            OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
+                        "pIf->mask\n");
+            memFreePtr(pctxt, pIf->name);
+            memFreePtr(pctxt, pIf->addr);
+            memFreePtr(pctxt, pIf);
+            return -1;
+         }
+         strcpy(pIf->mask, mask);
+#endif
+         pIf->next = NULL;
+
+         /* Add to the list */
+         if(!*ifList)
+         {
+            *ifList = pIf;
+            pIf = NULL;
+         }
+         else{
+            pIf->next = *ifList;
+            *ifList = pIf;
+            pIf=NULL;
+         }
+/*
+#if defined(OO_FREEBSD) || defined(OO_OPENBSD) || defined(OO_NETBSD) || defined(OO_MACOSX) || defined(OO_VXWORKS) || defined(OO_RTEMS) || defined(OO_QNX)
+#ifndef _SIZEOF_ADDR_IFREQ
+#define _SIZEOF_ADDR_IFREQ(ifr) \
+        ((ifr).ifr_addr.sa_len > sizeof(struct sockaddr) ? \
+         (sizeof(struct ifreq) - sizeof(struct sockaddr) + \
+          (ifr).ifr_addr.sa_len) : sizeof(struct ifreq))
+#endif
+      ifName = (struct ifreq *)((char *)ifName + _SIZEOF_ADDR_IFREQ(*ifName));
+#else
+      ifName++;
+*/
+      }
+
+   }  
+   return ASN_OK;
+}
+#endif
diff --git a/addons/ooh323c/src/ooSocket.h b/addons/ooh323c/src/ooSocket.h
new file mode 100644
index 000000000..6a28ef3ac
--- /dev/null
+++ b/addons/ooh323c/src/ooSocket.h
@@ -0,0 +1,403 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/** 
+ * @file ooSocket.h 
+ * Common runtime constants, data structure definitions, and run-time functions
+ * to support the sockets' operations.
+ */
+#ifndef _OOSOCKET_H_
+#define _OOSOCKET_H_
+
+#ifdef _WIN32_WCE
+#include <winsock.h>
+#elif defined(_WIN32) || defined(_WIN64)
+#include <sys/types.h>
+#define INCL_WINSOCK_API_TYPEDEFS   1
+#define INCL_WINSOCK_API_PROTOTYPES 0
+#include <winsock2.h>
+#else
+#include <sys/types.h>
+#include "sys/time.h"
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#endif
+
+#include "ooasn1.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#elif defined (USEASN1DLL)
+#define EXTERN __declspec(dllimport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+/** 
+ * @defgroup sockets Socket Layer
+ * @{
+ */
+#if defined (_WIN64)
+typedef unsigned __int64 OOSOCKET; /**< Socket's handle */
+#elif defined (_WIN32)
+typedef unsigned int OOSOCKET; /**< Socket's handle */
+#else
+typedef int OOSOCKET;          /**< Socket's handle */
+#endif
+
+#define OOSOCKET_INVALID ((OOSOCKET)-1)
+
+
+/** 
+ * The IP address represented as unsigned long value. The most significant 8
+ * bits in this unsigned long value represent the first number of the IP
+ * address. The least significant 8 bits represent the last number of the IP
+ * address.
+ */
+typedef unsigned long OOIPADDR;
+
+#define OOIPADDR_ANY   ((OOIPADDR)0)
+#define OOIPADDR_LOCAL ((OOIPADDR)0x7f000001UL) /* 127.0.0.1 */
+
+typedef struct OOInterface{
+   char *name;
+   char *addr;
+   char *mask;
+   struct OOInterface *next;
+}OOInterface;
+
+
+
+/**
+ * This function permits an incoming connection attempt on a socket. It
+ * extracts the first connection on the queue of pending connections on socket.
+ * It then creates a new socket and returns a handle to the new socket. The
+ * newly created socket is the socket that will handle the actual connection
+ * and has the same properties as original socket. See description of 'accept'
+ * socket function for further details.
+ *
+ * @param socket       The socket's handle created by call to ::rtSocketCreate
+ *                     function.
+ * @param pNewSocket   The pointer to variable to receive the new socket's
+ *                     handle.
+ * @param destAddr     Optional pointer to a buffer that receives the IP
+ *                     address of the connecting entity. It may be NULL.
+ * @param destPort     Optional pointer to a buffer that receives the port of
+ *                     the connecting entity. It may be NULL.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketAccept (OOSOCKET socket, OOSOCKET *pNewSocket, 
+                             OOIPADDR* destAddr, int* destPort);
+
+/**
+ * This function converts an IP address to its string representation.
+ *
+ * @param ipAddr       The IP address to be converted.
+ * @param pbuf         Pointer to the buffer to receive a string with the IP
+ *                     address.
+ * @param bufsize      Size of the buffer.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketAddrToStr (OOIPADDR ipAddr, char* pbuf, int bufsize);
+
+/**
+ * This function associates a local address with a socket. It is used on an
+ * unconnected socket before subsequent calls to the ::rtSocketConnect or
+ * ::rtSocketListen functions. See description of 'bind' socket function for
+ * further details.
+ *
+ * @param socket       The socket's handle created by call to ::rtSocketCreate
+ *                     function.
+ * @param addr         The local IP address to assign to the socket.
+ * @param port         The local port number to assign to the socket.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketBind (OOSOCKET socket, OOIPADDR addr, int port);
+
+/**
+ * This function closes an existing socket.
+ *
+ * @param socket       The socket's handle created by call to ::rtSocketCreate
+ *                     or ::rtSocketAccept function.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketClose (OOSOCKET socket);
+
+/**
+ * This function establishes a connection to a specified socket. It is used to
+ * create a connection to the specified destination. When the socket call
+ * completes successfully, the socket is ready to send and receive data. See
+ * description of 'connect' socket function for further details.
+ *
+ * @param socket       The socket's handle created by call to ::rtSocketCreate
+ *                     function.
+ * @param host         The null-terminated string with the IP address in the
+ *                     following format: "NNN.NNN.NNN.NNN", where NNN is a
+ *                     number in the range (0..255).
+ * @param port         The destination port to connect.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketConnect (OOSOCKET socket, const char* host, int port);
+
+/**
+ * This function creates a socket. The only streaming TCP/IP sockets are
+ * supported at the moment.
+ *
+ * @param psocket      The pointer to the socket's handle variable to receive
+ *                     the handle of new socket.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketCreate (OOSOCKET* psocket);
+
+/**
+ * This function creates a UDP datagram socket. 
+ *
+ * @param psocket      The pointer to the socket's handle variable to receive
+ *                     the handle of new socket.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketCreateUDP (OOSOCKET* psocket);
+
+/**
+ * This function initiates use of sockets by an application. This function must
+ * be called first before use sockets.
+ *
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketsInit (void);
+
+/**
+ * This function terminates use of sockets by an application. This function 
+ * must be called after done with sockets.
+ *
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketsCleanup (void);
+
+/**
+ * This function places a socket a state where it is listening for an incoming
+ * connection. To accept connections, a socket is first created with the
+ * ::rtSocketCreate function and bound to a local address with the
+ * ::rtSocketBind function, a maxConnection for incoming connections is
+ * specified with ::rtSocketListen, and then the connections are accepted with
+ * the ::rtSocketAccept function. See description of 'listen' socket function
+ * for further details.
+ *
+ * @param socket        The socket's handle created by call to
+ *                      ::rtSocketCreate function.
+ * @param maxConnection Maximum length of the queue of pending connections.
+ * @return              Completion status of operation: 0 (ASN_OK) =
+ *                      success, negative return value is error.
+ */
+EXTERN int ooSocketListen (OOSOCKET socket, int maxConnection);
+
+
+/**
+ * This function is used to peek at the received data without actually removing
+ * it from the receive socket buffer. A receive call after this will get the
+ * same data from the socket.
+ * @param socket       The socket's handle created by call to ::rtSocketCreate
+ *                     or ::rtSocketAccept function.
+ * @param pbuf         Pointer to the buffer for the incoming data.
+ * @param bufsize      Length of the buffer.
+ * @return             If no error occurs, returns the number of bytes
+ *                     received. Otherwise, the negative value is error code.
+ */
+EXTERN int ooSocketRecvPeek
+   (OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize);
+
+/**
+ * This function receives data from a connected socket. It is used to read
+ * incoming data on sockets. The socket must be connected before calling this
+ * function. See description of 'recv' socket function for further details.
+ *
+ * @param socket       The socket's handle created by call to ::rtSocketCreate
+ *                     or ::rtSocketAccept function.
+ * @param pbuf         Pointer to the buffer for the incoming data.
+ * @param bufsize      Length of the buffer.
+ * @return             If no error occurs, returns the number of bytes
+ *                     received. Otherwise, the negative value is error code.
+ */
+EXTERN int ooSocketRecv (OOSOCKET socket, ASN1OCTET* pbuf, 
+                           ASN1UINT bufsize);
+
+/**
+ * This function receives data from a connected/unconnected socket. It is used
+ * to read incoming data on sockets. It populates the remotehost and 
+ * remoteport parameters with information of remote host. See description of 
+ * 'recvfrom' socket function for further details.
+ *
+ * @param socket       The socket's handle created by call to ooSocketCreate
+ *                     
+ * @param pbuf         Pointer to the buffer for the incoming data.
+ * @param bufsize      Length of the buffer.
+ * @param remotehost   Pointer to a buffer in which remote ip address
+ *                     will be returned.
+ * @param hostBufLen   Length of the buffer passed for remote ip address.
+ * @param remoteport   Pointer to an int in which remote port number
+ *                     will be returned.
+ *
+ * @return             If no error occurs, returns the number of bytes
+ *                     received. Otherwise, negative value.
+ */
+EXTERN int ooSocketRecvFrom (OOSOCKET socket, ASN1OCTET* pbuf,
+                             ASN1UINT bufsize, char * remotehost, 
+                             ASN1UINT hostBufLen, int * remoteport);
+/**
+ * This function sends data on a connected socket. It is used to write outgoing
+ * data on a connected socket. See description of 'send' socket function for
+ * further details.
+ *
+ * @param socket       The socket's handle created by call to ::rtSocketCreate
+ *                     or ::rtSocketAccept function.
+ * @param pdata        Buffer containing the data to be transmitted.
+ * @param size         Length of the data in pdata.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketSend (OOSOCKET socket, const ASN1OCTET* pdata, 
+                           ASN1UINT size);
+
+/**
+ * This function sends data on a connected or unconnected socket. See 
+ * description of 'sendto' socket function for further details.
+ *
+ * @param socket       The socket's handle created by call to ::rtSocketCreate
+ *                       or ::rtSocketAccept function.
+ * @param pdata        Buffer containing the data to be transmitted.
+ * @param size         Length of the data in pdata.
+ * @param remotehost   Remote host ip address to which data has to 
+ *                     be sent.
+ * @param remoteport   Remote port ip address to which data has to 
+ *                     be sent.
+ *
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketSendTo(OOSOCKET socket, const ASN1OCTET* pdata, 
+                            ASN1UINT size, const char* remotehost,
+                            int remoteport);
+
+/**
+ * This function is used for synchronous monitoring of multiple sockets.
+ * For more information refer to documnetation of "select" system call. 
+ *
+ * @param nfds         The highest numbered descriptor to be monitored 
+ *                     plus one.
+ * @param readfds      The descriptors listed in readfds will be watched for 
+ *                     whether read would block on them.
+ * @param writefds     The descriptors listed in writefds will be watched for
+ *                     whether write would block on them.
+ * @param exceptfds    The descriptors listed in exceptfds will be watched for
+ *                     exceptions.
+ * @param timeout      Upper bound on amout of time elapsed before select 
+ *                     returns. 
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */                                                       
+EXTERN int ooSocketSelect(int nfds, fd_set *readfds, fd_set *writefds, 
+                            fd_set *exceptfds, struct timeval * timeout);
+
+/**
+ * This function converts the string with IP address to a double word
+ * representation. The converted address may be used with the ::rtSocketBind
+ * function.
+ *
+ * @param pIPAddrStr   The null-terminated string with the IP address in the
+ *                     following format: "NNN.NNN.NNN.NNN", where NNN is a
+ *                     number in the range (0..255).
+ * @param pIPAddr      Pointer to the converted IP address.
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketStrToAddr (const char* pIPAddrStr, OOIPADDR* pIPAddr);
+
+/**
+ * This function converts an internet dotted ip address to network address
+ *
+ * @param inetIp       The null-terminated string with the IP address in the
+ *                     following format: "NNN.NNN.NNN.NNN", where NNN is a
+ *                     number in the range (0..255).
+ * @param netIp        Buffer in which the converted address will be returned.
+
+ * @return             Completion status of operation: 0 (ASN_OK) = success,
+ *                     negative return value is error.
+ */
+EXTERN int ooSocketConvertIpToNwAddr(char *inetIp, char *netIp);
+
+/**
+ * This function retrives the IP address of the local host.
+ *
+ * @param pIPAddrs   Pointer to a char buffer in which local IP address will be
+ *                   returned.
+ * @return           Completion status of operation: 0 (ASN_OK) = success,
+ *                   negative return value is error.
+ */
+EXTERN int ooGetLocalIPAddress(char * pIPAddrs);
+
+
+EXTERN int ooSocketGetSockName(OOSOCKET socket, struct sockaddr_in *name, 
+                                                      int *size);
+
+
+EXTERN long ooSocketHTONL(long val);
+
+EXTERN short ooSocketHTONS(short val);
+
+/**
+ * This function is used to retrieve the ip and port number used by the socket
+ * passed as parameter. It internally uses getsockname system call for this 
+ * purpose.
+ * @param socket  Socket for which ip and port has to be determined.
+ * @param ip      Buffer in which ip address will be returned.
+ * @param len     Length of the ip address buffer.
+ * @param port    Pointer to integer in which port number will be returned.
+ *
+ * @return        ASN_OK, on success; -ve on failed.
+ */
+EXTERN int ooSocketGetIpAndPort(OOSOCKET socket, char *ip, int len, int *port);
+
+
+EXTERN int ooSocketGetInterfaceList(OOCTXT *pctxt, OOInterface **ifList);
+/** 
+ * @} 
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _OOSOCKET_H_ */
+
diff --git a/addons/ooh323c/src/ooStackCmds.c b/addons/ooh323c/src/ooStackCmds.c
new file mode 100644
index 000000000..a75a33cb0
--- /dev/null
+++ b/addons/ooh323c/src/ooStackCmds.c
@@ -0,0 +1,339 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooStackCmds.h"
+#include "ooh323ep.h"
+#include "ooCalls.h"
+#include "ooCmdChannel.h"
+
+extern OOSOCKET gCmdChan;
+
+int ooGenerateOutgoingCallToken (char *callToken, size_t size)
+{
+   static int counter = 1;
+   char aCallToken[200];
+   int  ret = 0;
+
+
+   sprintf (aCallToken, "ooh323c_o_%d", counter++);
+
+   if (counter > OO_MAX_CALL_TOKEN)
+      counter = 1;
+
+   if ((strlen(aCallToken)+1) < size)
+      strcpy (callToken, aCallToken);
+   else {
+      ret = OO_FAILED;
+   }
+
+   return ret;
+}
+
+
+OOStkCmdStat ooMakeCall 
+   (const char* dest, char* callToken, size_t bufsiz, ooCallOptions *opts)
+{
+   OOStackCommand cmd;
+
+   if(!callToken)
+      return OO_STKCMD_INVALIDPARAM;
+  
+
+   /* Generate call token*/
+   if (ooGenerateOutgoingCallToken (callToken, bufsiz) != OO_OK){
+      return OO_STKCMD_INVALIDPARAM;
+   }
+
+   if(gCmdChan == 0)
+   {
+      if(ooCreateCmdConnection() != OO_OK)
+         return OO_STKCMD_CONNECTIONERR;
+   }
+
+   memset(&cmd, 0, sizeof(OOStackCommand));
+   cmd.type = OO_CMD_MAKECALL;
+   cmd.param1 = (void*) malloc(strlen(dest)+1);
+   if(!cmd.param1)
+   {
+      return OO_STKCMD_MEMERR;
+   }
+   strcpy((char*)cmd.param1, dest);
+
+  
+   cmd.param2 = (void*) malloc(strlen(callToken)+1);
+   if(!cmd.param2)
+   {
+      free(cmd.param1);
+      return OO_STKCMD_MEMERR;
+   }
+   
+   strcpy((char*)cmd.param2, callToken);
+
+   if(!opts)
+   {
+      cmd.param3 = 0;
+   }
+   else {
+      cmd.param3 = (void*) malloc(sizeof(ooCallOptions));
+      if(!cmd.param3)
+      {
+         free(cmd.param1);
+         free(cmd.param2);
+         return OO_STKCMD_MEMERR;
+      }
+      memcpy((void*)cmd.param3, opts, sizeof(ooCallOptions));
+   }
+
+   if(ooWriteStackCommand(&cmd) != OO_OK)
+   {
+      free(cmd.param1);
+      free(cmd.param2);
+      if(cmd.param3) free(cmd.param3);
+      return OO_STKCMD_WRITEERR;
+   }
+
+   return OO_STKCMD_SUCCESS;
+}
+
+
+OOStkCmdStat ooManualRingback(const char *callToken)
+{
+   OOStackCommand cmd;
+   if(!callToken)
+   {
+      return OO_STKCMD_INVALIDPARAM;
+   }
+
+   if(gCmdChan == 0)
+   {
+      if(ooCreateCmdConnection() != OO_OK)
+         return OO_STKCMD_CONNECTIONERR;
+   }
+
+   memset(&cmd, 0, sizeof(OOStackCommand));
+   cmd.type = OO_CMD_MANUALRINGBACK;
+   cmd.param1 = (void*) malloc(strlen(callToken)+1);
+   if(!cmd.param1)
+   {
+      return OO_STKCMD_MEMERR;
+   }
+   strcpy((char*)cmd.param1, callToken);
+   
+   if(ooWriteStackCommand(&cmd) != OO_OK)
+   {
+      free(cmd.param1);
+      return OO_STKCMD_WRITEERR;
+   }
+
+   return OO_STKCMD_SUCCESS;
+}
+
+OOStkCmdStat ooAnswerCall(const char *callToken)
+{
+   OOStackCommand cmd;
+
+   if(!callToken)
+   {
+      return OO_STKCMD_INVALIDPARAM;
+   }
+
+   if(gCmdChan == 0)
+   {
+      if(ooCreateCmdConnection() != OO_OK)
+         return OO_STKCMD_CONNECTIONERR;
+   }
+
+   memset(&cmd, 0, sizeof(OOStackCommand));
+   cmd.type = OO_CMD_ANSCALL;
+
+   cmd.param1 = (void*) malloc(strlen(callToken)+1);
+   if(!cmd.param1)
+   {
+      return OO_STKCMD_MEMERR;
+   }
+   strcpy((char*)cmd.param1, callToken);
+   
+   if(ooWriteStackCommand(&cmd) != OO_OK)
+   {
+      free(cmd.param1);
+      return OO_STKCMD_WRITEERR;
+   }
+
+   return OO_STKCMD_SUCCESS;
+}
+
+OOStkCmdStat ooForwardCall(const char* callToken, char *dest)
+{
+   OOStackCommand cmd;
+
+   if(!callToken || !dest)
+   {
+      return OO_STKCMD_INVALIDPARAM;
+   }
+
+   if(gCmdChan == 0)
+   {
+      if(ooCreateCmdConnection() != OO_OK)
+         return OO_STKCMD_CONNECTIONERR;
+   }
+
+   memset(&cmd, 0, sizeof(OOStackCommand));
+   cmd.type = OO_CMD_FWDCALL;
+
+   cmd.param1 = (void*) malloc(strlen(callToken)+1);
+   cmd.param2 = (void*) malloc(strlen(dest)+1);
+   if(!cmd.param1 || !cmd.param2)
+   {
+      if(cmd.param1)   free(cmd.param1);  /* Release memory */
+      if(cmd.param2)   free(cmd.param2);
+      return OO_STKCMD_MEMERR;
+   }
+   strcpy((char*)cmd.param1, callToken);
+   strcpy((char*)cmd.param2, dest);
+
+   if(ooWriteStackCommand(&cmd) != OO_OK)
+   {
+      free(cmd.param1);
+      free(cmd.param2);
+      return OO_STKCMD_WRITEERR;
+   }
+
+   return OO_STKCMD_SUCCESS;
+}
+
+
+OOStkCmdStat ooHangCall(const char* callToken, OOCallClearReason reason)
+{
+   OOStackCommand cmd;
+
+   if(!callToken)
+   {
+      return OO_STKCMD_INVALIDPARAM;
+   }
+
+   if(gCmdChan == 0)
+   {
+      if(ooCreateCmdConnection() != OO_OK)
+         return OO_STKCMD_CONNECTIONERR;
+   }
+
+   memset(&cmd, 0, sizeof(OOStackCommand));
+   cmd.type = OO_CMD_HANGCALL;
+   cmd.param1 = (void*) malloc(strlen(callToken)+1);
+   cmd.param2 = (void*) malloc(sizeof(OOCallClearReason));
+   if(!cmd.param1 || !cmd.param2)
+   {
+      if(cmd.param1)   free(cmd.param1); /* Release memory */
+      if(cmd.param2)   free(cmd.param2);
+      return OO_STKCMD_MEMERR;
+   }
+   strcpy((char*)cmd.param1, callToken);
+   *((OOCallClearReason*)cmd.param2) = reason;
+
+   if(ooWriteStackCommand(&cmd) != OO_OK)
+   {
+      free(cmd.param1);
+      free(cmd.param2);
+      return OO_STKCMD_WRITEERR;
+   }
+   
+   return OO_STKCMD_SUCCESS;
+}
+
+
+OOStkCmdStat ooStopMonitor()
+{
+   OOStackCommand cmd;
+
+   if(gCmdChan == 0)
+   {
+      if(ooCreateCmdConnection() != OO_OK)
+         return OO_STKCMD_CONNECTIONERR;
+   }
+
+   memset(&cmd, 0, sizeof(OOStackCommand));
+   cmd.type = OO_CMD_STOPMONITOR;
+   
+   if(ooWriteStackCommand(&cmd) != OO_OK)
+      return OO_STKCMD_WRITEERR;
+
+   return OO_STKCMD_SUCCESS;
+}
+
+OOStkCmdStat ooSendDTMFDigit(const char *callToken, const char* dtmf)
+{
+   OOStackCommand cmd;
+
+   if(!callToken)
+   {
+      return OO_STKCMD_INVALIDPARAM;
+   }
+
+   if(gCmdChan == 0)
+   {
+      if(ooCreateCmdConnection() != OO_OK)
+         return OO_STKCMD_CONNECTIONERR;
+   }
+
+   memset(&cmd, 0, sizeof(OOStackCommand));
+   cmd.type = OO_CMD_SENDDIGIT;
+
+   cmd.param1 = (void*) malloc(strlen(callToken)+1);
+   cmd.param2 = (void*) malloc(strlen(dtmf)+1);
+   if(!cmd.param1 || !cmd.param2)
+   {
+      if(cmd.param1)   free(cmd.param1); /* Release memory */
+      if(cmd.param2)   free(cmd.param2);
+      return OO_STKCMD_MEMERR;
+   }
+   strcpy((char*)cmd.param1, callToken);
+   strcpy((char*)cmd.param2, dtmf);
+   
+   if(ooWriteStackCommand(&cmd) != OO_OK)
+   {
+      free(cmd.param1);
+      free(cmd.param2);
+      return OO_STKCMD_WRITEERR;
+   }
+
+   return OO_STKCMD_SUCCESS;
+}
+
+
+const char* ooGetStkCmdStatusCodeTxt(OOStkCmdStat stat)
+{
+   switch(stat)
+   {
+      case OO_STKCMD_SUCCESS:
+         return "Stack command - successfully issued";
+
+      case OO_STKCMD_MEMERR:
+         return "Stack command - Memory allocation error";
+
+      case OO_STKCMD_INVALIDPARAM:
+         return "Stack command - Invalid parameter";
+
+      case OO_STKCMD_WRITEERR:
+         return "Stack command - write error";
+
+      case OO_STKCMD_CONNECTIONERR: 
+         return "Stack command - Failed to create command channel";
+
+      default:
+         return "Invalid status code";
+   }
+}
+
diff --git a/addons/ooh323c/src/ooStackCmds.h b/addons/ooh323c/src/ooStackCmds.h
new file mode 100644
index 000000000..7ba9d7226
--- /dev/null
+++ b/addons/ooh323c/src/ooStackCmds.h
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file ooStackCmds.h 
+ * This file contains stack commands which an user application can use to make
+ * call, hang call etc. 
+ */
+
+#ifndef OO_STACKCMDS_H
+#define OO_STACKCMDS_H
+
+#include "ootypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#if defined (MAKE_DLL)
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+
+
+/** 
+ * @defgroup stackcmds Stack Control Commands
+ * @{
+ */
+
+/**
+ * This is an enumeration of Stack Command return codes.
+ */
+typedef enum OOStkCmdStat{
+  OO_STKCMD_SUCCESS,
+  OO_STKCMD_MEMERR,
+  OO_STKCMD_INVALIDPARAM,
+  OO_STKCMD_WRITEERR,
+  OO_STKCMD_CONNECTIONERR
+}OOStkCmdStat;
+
+/**
+ * This is an enumeration of stack command codes.
+ */
+typedef enum OOStackCmdID {
+   OO_CMD_NOOP,
+   OO_CMD_MAKECALL,          /*!< Make call */
+   OO_CMD_ANSCALL,           /*!< Answer call */
+   OO_CMD_FWDCALL,           /*!< Forward call */
+   OO_CMD_HANGCALL,          /*!< Terminate call */
+   OO_CMD_SENDDIGIT,         /*!< Send dtmf */
+   OO_CMD_MANUALRINGBACK,    /*!< Send Alerting - ringback */
+   OO_CMD_STOPMONITOR        /*!< Stop the event monitor */
+   
+} OOStackCmdID;
+
+/**
+ * This structure is used to queue a stack command for processing in 
+ * the event handler loop.
+ */
+typedef struct OOStackCommand {
+   OOStackCmdID type;
+   void* param1;
+   void* param2;
+   void* param3;
+} OOStackCommand;
+
+#define ooCommand OOStackCommand;
+
+/**
+ * This function is used by an application to place a call.
+ * @param dest        Call Destination - IP:port / alias
+ * @param callToken   Pointer to a buffer in which callToken will be returned
+ * @param bufsiz      Size of the callToken buffer passed.
+ * @param opts        These are call specific options and if passed a non-null
+ *                    value, will override global endpoint options.
+ *
+ * @return            Returns OOStkCmdStat value indication success or failure.
+ */
+EXTERN OOStkCmdStat ooMakeCall 
+   (const char* dest, char *callToken, size_t bufsiz, ooCallOptions *opts);
+
+
+
+/**
+ * This function is used to send a manual ringback message (alerting message)
+ * for a call. Effective only when manual-ringback is enabled.
+ * @param callToken    Unique token for the call.
+ * 
+ * @return            Returns OOStkCmdStat value indication success or failure.
+ */
+EXTERN OOStkCmdStat ooManualRingback(const char *callToken);
+
+/**
+ * This function is used to answer a call
+ * @param callToken   Unique token for the call
+ * 
+ * @return            Returns OOStkCmdStat value indication success or failure.
+ */
+EXTERN OOStkCmdStat ooAnswerCall(const char *callToken);
+
+/**
+ * This function is used to forward an existing call to third party.
+ * @param callToken   Unique token for the call.
+ * @param dest        Address to which the call has to be forwarded. Can be
+ *                    IP:PORT or alias.
+ *
+ * @return            Returns OOStkCmdStat value indication success or failure.
+ */
+EXTERN OOStkCmdStat ooForwardCall(const char* callToken, char *dest);
+
+/**
+ * This function is used by an user application to terminate a call.
+ * @param callToken   The uinque token for the call.
+ * @param reason      Reason for hanging call.
+ *
+ * @return            Returns OOStkCmdStat value indication success or failure.
+ */
+EXTERN OOStkCmdStat ooHangCall(const char* callToken, OOCallClearReason reason);
+
+/**
+ * This command function can be used by an user application to send a DTMF 
+ * sequence using H.245 UserInputIndication message.
+ * @param callToken  Unique token for the call
+ * @param alpha      Alphanumeric string reperesenting dtmf sequence
+ *
+ * @return            Returns OOStkCmdStat value indication success or failure.
+ */
+EXTERN OOStkCmdStat ooSendDTMFDigit(const char *callToken, const char* alpha);
+
+
+/**
+ * This function is used by the user application to stop stack thread.
+ *
+ * @return            Returns OOStkCmdStat value indication success or failure.
+ */
+EXTERN OOStkCmdStat ooStopMonitor(void);
+
+
+/**
+ * This function is used by application to obtain the text description for
+ * failure of tsack command.
+ * @param stat       Status code returned by stack command api.
+ *
+ * @return           Text description corresponding to the code.
+ */
+EXTERN const char* ooGetStkCmdStatusCodeTxt(OOStkCmdStat stat);
+/** 
+ * @} 
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/ooTimer.c b/addons/ooh323c/src/ooTimer.c
new file mode 100644
index 000000000..c91ec9ee3
--- /dev/null
+++ b/addons/ooh323c/src/ooTimer.c
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the LICENSE.txt file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooDateTime.h"
+#include "ooTimer.h"
+#include "ootrace.h"
+
+#define USECS_IN_SECS 1000000
+#define NSECS_IN_USECS 1000
+
+#ifndef MICROSEC
+#define MICROSEC USECS_IN_SECS
+#endif
+
+/**
+ * This is a timer list used by test application chansetup only. 
+ */
+
+DList g_TimerList;
+
+OOTimer* ooTimerCreate 
+(OOCTXT* pctxt, DList *pList, OOTimerCbFunc cb, OOUINT32 deltaSecs, void *data, 
+ OOBOOL reRegister)
+{
+   OOTimer* pTimer = (OOTimer*) memAlloc (pctxt, sizeof(OOTimer));
+   if (0 == pTimer) return 0;
+
+   memset (pTimer, 0, (sizeof(OOTimer)));
+   pTimer->timeoutCB = cb;
+   pTimer->cbData = data;
+   pTimer->reRegister = reRegister;
+   pTimer->timeout.tv_sec  = deltaSecs;
+   pTimer->timeout.tv_usec = 0;
+
+   /* Compute the absolute time at which this timer should expire */
+
+   ooTimerComputeExpireTime (pTimer);
+
+   /* Insert this timer into the complete list */
+   if(pList)
+      ooTimerInsertEntry (pctxt, pList, pTimer);
+   else
+      ooTimerInsertEntry (pctxt, &g_TimerList, pTimer);
+
+   return pTimer;
+}
+
+void ooTimerComputeExpireTime (OOTimer* pTimer)
+{
+   struct timeval tv;
+   ooGetTimeOfDay (&tv, 0);
+
+   /* Compute delta time to expiration */
+
+   pTimer->expireTime.tv_usec = tv.tv_usec + pTimer->timeout.tv_usec;
+   pTimer->expireTime.tv_sec  = tv.tv_sec  + pTimer->timeout.tv_sec;
+
+   while (pTimer->expireTime.tv_usec >= MICROSEC) {
+      pTimer->expireTime.tv_usec -= MICROSEC;
+      pTimer->expireTime.tv_sec++;
+   }
+}
+
+void ooTimerDelete (OOCTXT* pctxt, DList *pList, OOTimer* pTimer)
+{
+   dListFindAndRemove (pList, pTimer);
+   memFreePtr (pctxt, pTimer);
+}
+
+OOBOOL ooTimerExpired (OOTimer* pTimer)
+{
+   struct timeval tvstr;
+   ooGetTimeOfDay (&tvstr, 0);
+
+   if (tvstr.tv_sec > pTimer->expireTime.tv_sec)
+      return TRUE;
+
+   if ((tvstr.tv_sec == pTimer->expireTime.tv_sec) &&
+       (tvstr.tv_usec > pTimer->expireTime.tv_usec))
+      return TRUE;
+
+   return FALSE;
+}
+
+void ooTimerFireExpired (OOCTXT* pctxt, DList *pList)
+{
+   OOTimer* pTimer;
+   int stat;
+
+   while (pList->count > 0) {
+      pTimer = (OOTimer*) pList->head->data;
+
+      if (ooTimerExpired (pTimer)) {
+         /*
+          * Re-register before calling callback function in case it is
+          * a long duration callback.                                   
+          */
+         if (pTimer->reRegister) ooTimerReset (pctxt, pList, pTimer);
+
+         stat = (*pTimer->timeoutCB)(pTimer->cbData);
+
+         if (0 != stat || !pTimer->reRegister) {
+            ooTimerDelete (pctxt, pList, pTimer);
+         }
+      }
+      else break;
+   }
+}
+
+int ooTimerInsertEntry (OOCTXT* pctxt, DList *pList, OOTimer* pTimer)
+{  DListNode* pNode;
+   OOTimer* p;
+   int i = 0;
+
+   for (pNode = pList->head; pNode != 0; pNode = pNode->next) {
+      p = (OOTimer*) pNode->data;
+      if (pTimer->expireTime.tv_sec  <  p->expireTime.tv_sec) break;
+      if (pTimer->expireTime.tv_sec  == p->expireTime.tv_sec &&
+          pTimer->expireTime.tv_usec <= p->expireTime.tv_usec) break;
+      i++;
+   }
+
+   dListInsertBefore (pctxt, pList, pNode, pTimer);
+
+   return i;
+}
+
+struct timeval* ooTimerNextTimeout (DList *pList, struct timeval* ptimeout)
+{
+   OOTimer* ptimer;
+   struct timeval tvstr;
+
+   if (pList->count == 0) return 0;
+   ptimer = (OOTimer*) pList->head->data;
+
+   ooGetTimeOfDay (&tvstr, 0);
+
+   ptimeout->tv_sec = 
+      OOMAX ((int) 0, (int) (ptimer->expireTime.tv_sec - tvstr.tv_sec));   
+
+   ptimeout->tv_usec = ptimer->expireTime.tv_usec - tvstr.tv_usec;
+
+   while (ptimeout->tv_usec < 0) {
+      ptimeout->tv_sec--;
+      ptimeout->tv_usec += USECS_IN_SECS;
+   }
+
+   if (ptimeout->tv_sec < 0)
+      ptimeout->tv_sec = ptimeout->tv_usec = 0;
+
+   return (ptimeout);
+}
+
+/* 
+ * Reregister a timer entry.  This function is responsible for moving
+ * the current pointer in the timer list to the next element to be
+ * processed..
+ */
+void ooTimerReset (OOCTXT* pctxt, DList *pList, OOTimer* pTimer)
+{
+   if (pTimer->reRegister) {
+      dListFindAndRemove (pList, pTimer);
+      ooTimerComputeExpireTime (pTimer);
+      ooTimerInsertEntry (pctxt, pList, pTimer);
+   }
+   else
+      ooTimerDelete (pctxt, pList, pTimer);
+}
+
+int ooCompareTimeouts(struct timeval *to1, struct timeval *to2)
+{
+
+   if(to1->tv_sec > to2->tv_sec)   return 1;
+   if(to1->tv_sec < to2->tv_sec)   return -1;
+
+   if(to1->tv_usec > to2->tv_usec)   return 1;
+   if(to1->tv_usec < to2->tv_usec)   return -1;
+
+   return 0;
+}
diff --git a/addons/ooh323c/src/ooTimer.h b/addons/ooh323c/src/ooTimer.h
new file mode 100644
index 000000000..2283ba4d9
--- /dev/null
+++ b/addons/ooh323c/src/ooTimer.h
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the LICENSE.txt file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/** 
+ * @file ooTimer.h 
+ * Timer structures and functions.
+ */
+#ifndef _OOTIMER_H_
+#define _OOTIMER_H_
+
+#include "ooasn1.h"
+#include "ooSocket.h"   /* needed for timeval */
+
+struct _OOTimer;
+
+typedef int (*OOTimerCbFunc)(void *data);
+
+typedef struct _OOTimer {
+   struct timeval expireTime, timeout;
+   void*        cbData;
+   OOBOOL       reRegister;
+
+   /* Callback functions */
+   OOTimerCbFunc timeoutCB;
+} OOTimer;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * This function computes the relative expiration time from the current 
+ * time for the given timer object.
+ *
+ * @param pTimer       Pointer to timer object.
+ */
+EXTERN void ooTimerComputeExpireTime (OOTimer* pTimer);
+
+/**
+ * This function creates and initializes a new timer object.
+ * @param pctxt        OOCTXT structure used for timer memory allocation.
+ * @param pList        Pointer to timer list in which newly created timer will
+ *                     be inserted.
+ * @param cb           Timer callback function.
+ * @param deltaSecs    Time in seconds to timer expiration.
+ * @param data         Callback user data argument.
+ * @param reRegister   Should timer be re-registered after it expires?
+ * @return             Pointer to created timer object.
+ */
+EXTERN OOTimer* ooTimerCreate 
+(OOCTXT* pctxt, DList *pList, OOTimerCbFunc cb, OOUINT32 deltaSecs, void *data,
+ OOBOOL reRegister);
+
+/**
+ * This function deletes the given timer object.
+ * @param pctxt        Handle to OOCTXT structure used for timer memory.
+ * @param pList        timer list to operate on
+ * @param pTimer       Pointer to timer object.
+ */
+EXTERN void ooTimerDelete (OOCTXT* pctxt, DList* pList, OOTimer* pTimer);
+
+/**
+ * This function checks a timer to determine if it is expired.
+ *
+ * @param pTimer       Pointer to timer object.
+ * @return             True if timer expired, false if not.
+ */
+EXTERN OOBOOL ooTimerExpired (OOTimer* pTimer);
+
+/**
+ * This function loops through the global timer list and fires all 
+ * expired timers by calling the registered callback functions.
+ */
+EXTERN void ooTimerFireExpired (OOCTXT* pctxt, DList* pList);
+
+/**
+ * This function inserts the given timer object into the correct 
+ * chronological position in the global timer list.
+ * @param pctxt        Pointer to OOCTXT structure used for memory allocation.
+ * @param pList        List in which timer has to be inserted.
+ * @param pTimer       Pointer to timer object.
+ * @return             Index to position where inserted in list.
+ */
+EXTERN int ooTimerInsertEntry (OOCTXT* pctxt, DList* pList, OOTimer* pTimer);
+
+/**
+ * This function calculates the relative time from the current time 
+ * that the first timer in global timer list will expire.
+ * @param pList         Handle to timer list
+ * @param ptimeout      timeval structure to receive timeout value.
+ * @return              ptimeout
+ */
+EXTERN struct timeval* ooTimerNextTimeout (DList* pList, struct timeval* ptimeout);
+
+/**
+ * This function resets the given timer object if its reregister flag 
+ * is set.  Otherwise, it is deleted.
+ * @param pctxt        Pointer to OOCTXT structre used for memory allocation.
+ * @param pList        Pointer to timer list.
+ * @param pTimer       Pointer to timer object.
+ */
+EXTERN void ooTimerReset (OOCTXT* pctxt, DList* pList, OOTimer* pTimer);
+
+
+/**
+ * This function is used to compare two timeout values.
+ * @param to1          First timeout value.
+ * @param to2          Second timeout value.
+ *
+ * @return             1, if to1 > to2; 0, if to1 == to2; -1, if to1 < to2
+ */
+int ooCompareTimeouts(struct timeval *to1, struct timeval *to2);
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/addons/ooh323c/src/ooUtils.c b/addons/ooh323c/src/ooUtils.c
new file mode 100644
index 000000000..71b285f62
--- /dev/null
+++ b/addons/ooh323c/src/ooUtils.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooUtils.h"
+
+const char* ooUtilsGetText (OOUINT32 idx, const char** table, size_t tabsiz)
+{
+   return (idx < tabsiz) ? table[idx] : "?";
+}
+
+OOBOOL ooUtilsIsStrEmpty (const char* str)
+{
+   return (str == NULL || *str =='\0');
+}
+
+
+OOBOOL ooIsDailedDigit(const char* str) 
+{
+   if(str == NULL || *str =='\0') { return FALSE; }
+   while(*str != '\0')
+   {
+      if(!isdigit(*str) &&
+         *str != '#' && *str != '*' && *str != ',') { return FALSE; }
+      str++;
+   }
+   return TRUE;
+}
diff --git a/addons/ooh323c/src/ooUtils.h b/addons/ooh323c/src/ooUtils.h
new file mode 100644
index 000000000..1a84dd42e
--- /dev/null
+++ b/addons/ooh323c/src/ooUtils.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file ooUtils.h 
+ * This file contains general utility functions. 
+ */
+#ifndef _OOUTILS_H_
+#define _OOUTILS_H_
+#include "ootypes.h"
+
+/**
+ * Get text from a text table for a given enumeration index.
+ *
+ * @param idx    Index of item in table
+ * @param table  The table containing the text items
+ * @param tabsiz Number of items in the table
+ * @return  Text for item or '?' if idx outside bounds of table
+ */
+EXTERN const char* ooUtilsGetText 
+(OOUINT32 idx, const char** table, size_t tabsiz);
+
+/**
+ * Test if given string value is empty.  String is considered to empty 
+ * if value is NULL or there are no characters in string (strlen == 0).
+ *
+ * @param str    String to test
+ * @return       TRUE if string empty; FALSE otherwise
+ */
+EXTERN OOBOOL ooUtilsIsStrEmpty (const char * str);
+
+
+/**
+ * Test if given string value is digit string.  
+ *
+ * @param str    String to test
+ * @return       TRUE if string contains all digits; FALSE otherwise
+ */
+EXTERN OOBOOL ooIsDailedDigit(const char* str);
+
+#endif
diff --git a/addons/ooh323c/src/ooasn1.h b/addons/ooh323c/src/ooasn1.h
new file mode 100644
index 000000000..47219fac2
--- /dev/null
+++ b/addons/ooh323c/src/ooasn1.h
@@ -0,0 +1,1814 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/** 
+ * @file ooasn1.h 
+ * Common ASN.1 runtime constants, data structure definitions, and run-time
+ * functions to support ASN.1 PER encoding/decoding as defined in the 
+ * ITU-T standards.
+ */
+#ifndef _OOASN1_H_
+#define _OOASN1_H_
+
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+#include <stddef.h>
+#include "dlist.h"
+#include "ootrace.h"
+/** 
+ * @defgroup cruntime C Runtime Common Functions 
+ * @{
+ */
+
+/* Error Code Constants */
+
+#define ASN_OK            0      /* normal completion status             */
+#define ASN_OK_FRAG       2      /* message fragment detected            */
+#define ASN_E_BUFOVFLW   -1      /* encode buffer overflow               */
+#define ASN_E_ENDOFBUF   -2      /* unexpected end of buffer on decode   */
+#define ASN_E_IDNOTFOU   -3      /* identifer not found                  */
+#define ASN_E_INVOBJID   -4      /* invalid object identifier            */
+#define ASN_E_INVLEN     -5      /* invalid field length                 */
+#define ASN_E_INVENUM    -6      /* enumerated value not in defined set  */
+#define ASN_E_SETDUPL    -7      /* duplicate element in set             */
+#define ASN_E_SETMISRQ   -8      /* missing required element in set      */
+#define ASN_E_NOTINSET   -9      /* element not part of set              */
+#define ASN_E_SEQOVFLW   -10     /* sequence of field overflow           */
+#define ASN_E_INVOPT     -11     /* invalid option encountered in choice */
+#define ASN_E_NOMEM      -12     /* no dynamic memory available          */
+#define ASN_E_INVHEXS    -14     /* invalid hex string                   */
+#define ASN_E_INVBINS    -15     /* invalid binary string                */
+#define ASN_E_INVREAL    -16     /* invalid real value                   */
+#define ASN_E_STROVFLW   -17     /* octet or bit string field overflow   */
+#define ASN_E_BADVALUE   -18     /* invalid value specification          */
+#define ASN_E_UNDEFVAL   -19     /* no def found for ref'd defined value */
+#define ASN_E_UNDEFTYP   -20     /* no def found for ref'd defined type  */
+#define ASN_E_BADTAG     -21     /* invalid tag value                    */
+#define ASN_E_TOODEEP    -22     /* nesting level is too deep            */
+#define ASN_E_CONSVIO    -23     /* value constraint violation           */
+#define ASN_E_RANGERR    -24     /* invalid range (lower > upper)        */
+#define ASN_E_ENDOFFILE  -25     /* end of file on file decode           */
+#define ASN_E_INVUTF8    -26     /* invalid UTF-8 encoding               */
+#define ASN_E_CONCMODF   -27     /* Concurrent list modification         */
+#define ASN_E_ILLSTATE   -28     /* Illegal state error                  */
+#define ASN_E_OUTOFBND   -29     /* out of bounds (of array, etc)        */
+#define ASN_E_INVPARAM   -30     /* invalid parameter                    */
+#define ASN_E_INVFORMAT  -31     /* invalid time string format           */
+#define ASN_E_NOTINIT    -32     /* not initialized                      */
+#define ASN_E_TOOBIG     -33     /* value is too big for given data type */
+#define ASN_E_INVCHAR    -34     /* invalid character (not in char set)  */
+#define ASN_E_XMLSTATE   -35     /* XML state error                      */
+#define ASN_E_XMLPARSE   -36     /* XML parse error                      */
+#define ASN_E_SEQORDER   -37     /* SEQUENCE elements not in order       */
+#define ASN_E_INVINDEX   -38     /* invalid index for TC id              */
+#define ASN_E_INVTCVAL   -39     /* invalid value for TC field           */
+#define ASN_E_FILNOTFOU  -40     /* file not found                       */
+#define ASN_E_FILEREAD   -41     /* error occurred reading file          */
+#define ASN_E_FILEWRITE  -42     /* error occurred writing file          */
+#define ASN_E_INVBASE64  -43     /* invalid base64 encoding              */
+#define ASN_E_INVSOCKET  -44     /* invalid socket operation             */
+#define ASN_E_XMLLIBNFOU -45     /* XML library is not found             */
+#define ASN_E_XMLLIBINV  -46     /* XML library is invalid               */
+#define ASN_E_NOTSUPP    -99     /* non-supported ASN construct          */
+#define ASN_K_INDEFLEN   -9999   /* indefinite length message indicator  */
+
+/* universal built-in type ID code value constants */
+
+#define ASN_ID_EOC      0       /* end of contents              */
+#define ASN_ID_BOOL     1       /* boolean                      */
+#define ASN_ID_INT      2       /* integer                      */
+#define ASN_ID_BITSTR   3       /* bit string                   */
+#define ASN_ID_OCTSTR   4       /* byte (octet) string          */
+#define ASN_ID_NULL     5       /* null                         */
+#define ASN_ID_OBJID    6       /* object ID                    */
+#define ASN_ID_OBJDSC   7       /* object descriptor            */
+#define ASN_ID_EXTERN   8       /* external type                */
+#define ASN_ID_REAL     9       /* real                         */
+#define ASN_ID_ENUM     10      /* enumerated value             */
+#define ASN_ID_EPDV     11      /* EmbeddedPDV type             */
+#define ASN_ID_RELOID   13      /* relative object ID           */
+#define ASN_ID_SEQ      16      /* sequence, sequence of        */
+#define ASN_ID_SET      17      /* set, set of                  */
+
+#define ASN_SEQ_TAG     0x30    /* SEQUENCE universal tag byte  */
+#define ASN_SET_TAG     0x31    /* SET universal tag byte       */
+
+/* Restricted character string type ID's */
+
+#define ASN_ID_NumericString    18
+#define ASN_ID_PrintableString  19
+#define ASN_ID_TeletexString    20
+#define ASN_ID_T61String        ASN_ID_TeletexString
+#define ASN_ID_VideotexString   21
+#define ASN_ID_IA5String        22
+#define ASN_ID_UTCTime          23
+#define ASN_ID_GeneralTime      24
+#define ASN_ID_GraphicString    25
+#define ASN_ID_VisibleString    26
+#define ASN_ID_GeneralString    27
+#define ASN_ID_UniversalString  28
+#define ASN_ID_BMPString        30
+
+/* flag mask values */
+
+#define XM_SEEK         0x01    /* seek match until found or end-of-buf */
+#define XM_ADVANCE      0x02    /* advance pointer to contents on match */
+#define XM_DYNAMIC      0x04    /* alloc dyn mem for decoded variable   */
+#define XM_SKIP         0x08    /* skip to next field after parsing tag */
+
+/* Sizing Constants */
+
+#define ASN_K_MAXDEPTH  32      /* maximum nesting depth for messages   */
+#define ASN_K_MAXSUBIDS 128     /* maximum sub-id's in an object ID     */
+#define ASN_K_MAXENUM   100     /* maximum enum values in an enum type  */
+#define ASN_K_MAXERRP   5       /* maximum error parameters             */
+#define ASN_K_MAXERRSTK 8       /* maximum levels on error ctxt stack   */
+#define ASN_K_ENCBUFSIZ 2*1024 /* dynamic encode buffer extent size    */
+#define ASN_K_MEMBUFSEG 1024    /* memory buffer extent size            */
+
+/* Canonical character set definitions */
+
+#define NUM_ABITS  4
+#define NUM_UBITS  4
+#define NUM_CANSET \
+" 0123456789"
+
+#define PRN_ABITS  8
+#define PRN_UBITS  7
+#define PRN_CANSET \
+" '()+,-./0123456789:=?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+#define VIS_ABITS  8
+#define VIS_UBITS  7
+#define VIS_CANSET \
+" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]"\
+"^_`abcdefghijklmnopqrstuvwxyz{|}~"
+
+#define T61_ABITS  8
+#define T61_UBITS  7
+#define T61_CANSET \
+" !\"%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]"\
+"_abcdefghijklmnopqrstuvwxyz"
+
+#define IA5_ABITS  8
+#define IA5_UBITS  7
+#define IA5_CANSET \
+"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"\
+"\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"\
+" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]"\
+"^_`abcdefghijklmnopqrstuvwxyz{|}~"
+
+#define IA5_RANGE1_LOWER 0
+#define IA5_RANGE2_LOWER 0x5f
+
+#define GEN_ABITS  8
+#define GEN_UBITS  7
+#define GEN_CANSET \
+"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"\
+"\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"\
+" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"\
+"`abcdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207"\
+"\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237"\
+"\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"\
+"\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277"\
+"\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"\
+"\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"\
+"\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"\
+"\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377"
+
+#define BMP_ABITS  16
+#define BMP_UBITS  16
+#define BMP_FIRST  0
+#define BMP_LAST   0xffff
+
+#define UCS_ABITS  32
+#define UCS_UBITS  32
+#define UCS_FIRST  0
+#define UCS_LAST   0xfffffffful
+
+/* ASN.1 Primitive Type Definitions */
+
+typedef char            ASN1CHAR;
+typedef unsigned char   ASN1OCTET;
+typedef ASN1OCTET       ASN1BOOL;
+typedef signed char     ASN1INT8;
+typedef unsigned char   ASN1UINT8;
+typedef int             ASN1INT;
+typedef unsigned int    ASN1UINT;
+typedef ASN1INT         ASN1ENUM;
+typedef double          ASN1REAL;
+
+typedef short           ASN1SINT;
+typedef unsigned short  ASN1USINT;
+typedef ASN1UINT        ASN1TAG;
+#define ASN1TAG_LSHIFT  24
+typedef ASN1USINT       ASN116BITCHAR;
+typedef ASN1UINT        ASN132BITCHAR;
+typedef void*           ASN1ANY;
+
+#define ASN1UINT_MAX    4294967295U
+#define ASN1INT_MAX     ((ASN1INT)2147483647L)
+#define ASN1INT_MIN     ((ASN1INT)(-ASN1INT_MAX-1))
+
+#define ASN1UINTCNT(val) val##u
+
+
+#ifndef ASN1INT64
+
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__WATCOMC__) || \
+defined(_WIN32)
+#define ASN1INT64 __int64
+
+#elif defined(__IBMC__) || defined(__GNUC__) || defined(__SUNPRO_C) || \
+defined(__SUNPRO_CC) || defined(__CC_ARM) || \
+defined(__HPUX_CC__) || defined(__HP_aCC) 
+#define ASN1INT64 long long
+
+#else  /* !MSC_VER && !__IBMC__ etc */
+#define ASN1INT64 long
+
+#endif
+#endif /* ASN1INT64 */
+
+#ifndef FALSE
+#define FALSE           0
+#define TRUE            1
+#endif
+
+typedef struct {        /* object identifier */
+   ASN1UINT     numids;
+   ASN1UINT     subid[ASN_K_MAXSUBIDS];
+} ASN1OBJID;
+
+typedef struct {        /* generic octet string structure */
+   ASN1UINT     numocts;
+   ASN1OCTET    data[1];
+} ASN1OctStr;
+
+typedef struct {        /* generic octet string structure (dynamic) */
+   ASN1UINT     numocts;
+   const ASN1OCTET* data;
+} ASN1DynOctStr;
+
+typedef struct {        /* generic bit string structure (dynamic) */
+   ASN1UINT     numbits;
+   const ASN1OCTET* data;
+} ASN1DynBitStr;
+
+typedef struct {                /* generic sequence of structure        */
+   ASN1UINT     n;
+   void*        elem;
+} ASN1SeqOf;
+
+typedef struct {                /* sequence of OCTET STRING             */
+   ASN1UINT     n;
+   ASN1DynOctStr* elem;
+} ASN1SeqOfOctStr;
+
+typedef struct {                /* generic open type data structure     */
+   ASN1UINT     numocts;
+   const ASN1OCTET* data;
+} ASN1OpenType;
+
+/* ASN.1 useful type definitions */
+
+typedef struct {
+   ASN1UINT       nchars;
+   ASN116BITCHAR* data;
+} Asn116BitCharString;
+
+typedef struct {
+   ASN1UINT       nchars;
+   ASN132BITCHAR* data;
+} Asn132BitCharString;
+
+typedef const char*   ASN1GeneralizedTime;
+typedef const char*   ASN1GeneralString;
+typedef const char*   ASN1GraphicString;
+typedef const char*   ASN1IA5String;
+typedef const char*   ASN1ISO646String;
+typedef const char*   ASN1NumericString;
+typedef const char*   ASN1ObjectDescriptor;
+typedef const char*   ASN1PrintableString;
+typedef const char*   ASN1TeletexString;
+typedef const char*   ASN1T61String;
+typedef const char*   ASN1UTCTime;
+typedef const char*   ASN1UTF8String;
+typedef const char*   ASN1VideotexString;
+typedef const char*   ASN1VisibleString;
+
+typedef Asn116BitCharString ASN1BMPString;
+typedef Asn132BitCharString ASN1UniversalString;
+
+/* ASN.1 constrained string structures */
+
+typedef struct {
+   int          nchars;
+   char         data[255];
+} Asn1CharArray;
+
+typedef struct {
+   Asn1CharArray charSet;
+   const char* canonicalSet;
+   int          canonicalSetSize;
+   unsigned     canonicalSetBits;
+   unsigned     charSetUnalignedBits;
+   unsigned     charSetAlignedBits;
+} Asn1CharSet;
+
+typedef struct {
+   Asn116BitCharString charSet;
+   ASN1USINT    firstChar, lastChar;
+   unsigned     unalignedBits;
+   unsigned     alignedBits;
+} Asn116BitCharSet;
+
+/* ASN.1 size constraint structure */
+
+typedef struct _Asn1SizeCnst {
+   ASN1BOOL     extended;
+   ASN1UINT     lower;
+   ASN1UINT     upper;
+   struct _Asn1SizeCnst* next;
+} Asn1SizeCnst;
+
+/* ASN.1 encode/decode buffer info structure */
+
+typedef struct {
+   ASN1OCTET*   data;           /* pointer to start of data buffer      */
+   ASN1UINT     byteIndex;      /* byte index                           */
+   ASN1UINT     size;           /* current buffer size                  */
+   ASN1SINT     bitOffset;      /* current bit offset (8 - 1)           */
+   ASN1BOOL     dynamic;        /* is buffer dynamic?                   */
+} ASN1BUFFER;
+
+/* This structure is used to save the current state of the buffer */
+
+typedef struct {
+   ASN1UINT     byteIndex;      /* byte index                           */
+   ASN1SINT     bitOffset;      /* current bit offset (8 - 1)           */
+   ASN1USINT    flags;          /* flag bits                            */
+} ASN1BUFSAVE;
+
+/* ASN.1 run-time error info structures */
+
+typedef struct {
+   const char* module;
+   int          lineno;
+} ASN1ErrLocn;
+
+typedef struct {
+   ASN1ErrLocn  stack[ASN_K_MAXERRSTK];
+   int          stkx;
+   int          status;
+   int          parmcnt;
+   const char* parms[ASN_K_MAXERRP];
+} ASN1ErrInfo;
+
+#define XM_K_MEMBLKSIZ  (4*1024)
+
+/* Flag mask constant values */
+
+#define ASN1DYNCTXT     0x8000
+#define ASN1INDEFLEN    0x4000
+#define ASN1TRACE       0x2000
+#define ASN1LASTEOC     0x1000
+#define ASN1FASTCOPY    0x0800  /* turns on the "fast copy" mode        */
+#define ASN1CONSTAG     0x0400  /* form of last parsed tag              */
+#define ASN1CANXER      0x0200  /* canonical XER                        */
+#define ASN1SAVEBUF     0x0100  /* do not free dynamic encode buffer    */
+#define ASN1OPENTYPE    0x0080  /* item is an open type field           */
+
+/* ASN.1 encode/decode context block structure */
+
+struct EventHandler;
+
+typedef struct OOCTXT {         /* context block                        */
+   void*        pMsgMemHeap;    /* internal message memory heap         */
+   void*        pTypeMemHeap;   /* memory heap                          */
+   ASN1BUFFER   buffer;         /* data buffer                          */
+   ASN1ErrInfo  errInfo;        /* run-time error info                  */
+   Asn1SizeCnst* pSizeConstraint;  /* Size constraint list              */
+   const char* pCharSet;        /* String of permitted characters       */
+   struct EventHandler* pEventHandler; /* event handler object          */
+   ASN1USINT    flags;          /* flag bits                            */
+   ASN1OCTET    spare[2];
+} OOCTXT;
+
+/* macros and function prototypes */
+
+#ifndef ASN1MAX
+#define ASN1MAX(a,b)        (((a)>(b))?(a):(b))
+#endif
+
+#ifndef ASN1MIN
+#define ASN1MIN(a,b)        (((a)<(b))?(a):(b))
+#endif
+
+/**
+ * @defgroup mem Memory Allocation Macros and Functions 
+ * @ingroup cruntime
+ *
+ * Memory allocation functions and macros handle memory management for the
+ * ASN1C run-time. Special algorithms are used for allocation and deallocation
+ * of memory to improve the run-time performance. @{
+ */
+/**
+ * Allocate a dynamic array. This macro allocates a dynamic array of records of
+ * the given type. This version of the macro will return the ASN_E_NOMEM error
+ * status if the memory request cannot be fulfilled.
+ *
+ * @param pctxt        - Pointer to a context block
+ * @param pseqof       - Pointer to a generated SEQUENCE OF array structure.
+ *                       The <i>n</i> member variable must be set to the number
+ *                       of records to allocate.
+ * @param type         - Data type of an array record
+ */
+#define ALLOC_ASN1ARRAY(pctxt,pseqof,type) do {\
+if (sizeof(type)*(pseqof)->n < (pseqof)->n) return ASN_E_NOMEM; \
+if (((pseqof)->elem = (type*) memHeapAlloc \
+(&(pctxt)->pTypeMemHeap, sizeof(type)*(pseqof)->n)) == 0) return ASN_E_NOMEM; \
+} while (0)
+
+/**
+ * Allocate and zero an ASN.1 element. This macro allocates and zeros a single
+ * element of the given type.
+ *
+ * @param pctxt        - Pointer to a context block
+ * @param type         - Data type of record to allocate
+ */
+#define ALLOC_ASN1ELEM(pctxt,type) \
+(type*) memHeapAllocZ (&(pctxt)->pTypeMemHeap, sizeof(type))
+
+/**
+ * Allocate memory. This macro allocates the given number of bytes. It is
+ * similar to the C \c malloc run-time function.
+ *
+ * @param pctxt        - Pointer to a context block
+ * @param nbytes       - Number of bytes of memory to allocate
+ * @return             - Void pointer to allocated memory or NULL if
+ *                       insufficient memory was available to fulfill the
+ *                       request.
+ */
+#define ASN1MALLOC(pctxt,nbytes) \
+memHeapAlloc(&(pctxt)->pTypeMemHeap, nbytes)
+
+/**
+ * Free memory associated with a context. This macro frees all memory held
+ * within a context. This is all memory allocated using the ASN1MALLOC (and
+ * similar macros) and the mem memory allocation functions using the given
+ * context variable.
+ *
+ * @param pctxt        - Pointer to a context block
+ */
+#define ASN1MEMFREE(pctxt) \
+memHeapFreeAll(&(pctxt)->pTypeMemHeap)
+
+/**
+ * Free memory pointer. This macro frees memory at the given pointer. The
+ * memory must have been allocated using the ASN1MALLOC (or similar) macros or
+ * the mem memory allocation functions. This macro is similar to the C \c
+ * free function.
+ *
+ * @param pctxt        - Pointer to a context block
+ * @param pmem         - Pointer to memory block to free. This must have been
+ *                       allocated using the ASN1MALLOC macro or the
+ *                       memHeapAlloc function.
+ */
+#define ASN1MEMFREEPTR(pctxt,pmem)  \
+memHeapFreePtr(&(pctxt)->pTypeMemHeap, (void*)pmem)
+
+/**
+ * @}
+ */
+#define ASN1BUFCUR(cp)          (cp)->buffer.data[(cp)->buffer.byteIndex]
+#define ASN1BUFPTR(cp)          &(cp)->buffer.data[(cp)->buffer.byteIndex]
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#elif defined (USEASN1DLL)
+#define EXTERN __declspec(dllimport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+#ifndef _NO_MALLOC
+#define ASN1CRTMALLOC0(nbytes)       malloc(nbytes)
+#define ASN1CRTFREE0(ptr)            free(ptr)
+#else
+
+#ifdef _NO_THREADS
+extern EXTERN OOCTXT g_ctxt;
+
+#define ASN1CRTMALLOC0(nbytes)       memAlloc(&g_ctxt,(nbytes))
+#define ASN1CRTFREE0(ptr)            memFreePtr(&g_ctxt,(ptr))
+#else
+#define ASN1CRTMALLOC0(nbytes)       (void*)0
+#define ASN1CRTFREE0(ptr)            (void*)0
+
+#endif /* _NO_THREADS */
+#endif /* _NO_MALLOC */
+
+#define ASN1CRTMALLOC memHeapAlloc
+#define ASN1CRTFREE   ASN1MEMFREEPTR
+
+/* Function prototypes */
+
+#define DE_INCRBITIDX(pctxt) \
+((--(pctxt)->buffer.bitOffset < 0) ? \
+((++(pctxt)->buffer.byteIndex >= (pctxt)->buffer.size) ? ASN_E_ENDOFBUF : \
+((pctxt)->buffer.bitOffset = 7, ASN_OK)) : ASN_OK)
+
+
+#define DE_BIT(pctxt,pvalue) \
+((DE_INCRBITIDX (pctxt) != ASN_OK) ? ASN_E_ENDOFBUF : ((pvalue) ? \
+((*(pvalue) = (((pctxt)->buffer.data[(pctxt)->buffer.byteIndex]) & \
+(1 << (pctxt)->buffer.bitOffset)) != 0), ASN_OK) : ASN_OK ))
+
+
+#define encodeIA5String(pctxt,value,permCharSet) \
+encodeConstrainedStringEx (pctxt, value, permCharSet, 8, 7, 7)
+
+#define encodeGeneralizedTime   encodeIA5String
+
+#define decodeIA5String(pctxt,pvalue,permCharSet) \
+decodeConstrainedStringEx (pctxt, pvalue, permCharSet, 8, 7, 7)
+
+#define decodeGeneralizedTime   decodeIA5String
+
+/* run-time error and diagnostic functions */
+
+/* Context management functions */
+
+/**
+ * @defgroup cmfun Context Management Functions 
+ * @{
+ *
+ * Context initialization functions handle the allocation, initialization, and
+ * destruction of ASN.1 context variables (variables of type OOCTXT). These
+ * variables hold all of the working data used during the process of encoding
+ * or decoding a message. The context provides thread safe operation by
+ * isolating what would otherwise be global variables within this structure.
+ * The context variable is passed from function to function as a message is
+ * encoded or decoded and maintains state information on the encoding or
+ * decoding process.
+ */
+
+/**
+ * This function assigns a buffer to a context block. The block should have
+ * been previously initialized by initContext.
+ *
+ * @param pctxt        The pointer to the context structure variable to be
+ *                     initialized.
+ * @param bufaddr      For encoding, the address of a memory buffer to receive
+ *                     and encode a message. For decoding the address of a
+ *                     buffer that contains the message data to be decoded.
+ *                     This address will be stored within the context
+ *                     structure. For encoding it might be zero, the dynamic
+ *                     buffer will be used in this case.
+ * @param bufsiz       The size of the memory buffer. For encoding, it might be
+ *                     zero; the dynamic buffer will be used in this case.
+ * @return             Completion status of operation:
+ *                     - 0 (ASN_OK) = success,
+ *                     - negative return value is error.
+ */
+EXTERN int initContextBuffer 
+(OOCTXT* pctxt, const ASN1OCTET* bufaddr, ASN1UINT bufsiz);
+
+/**
+ * This function initializes a context block. It makes sure that if the block
+ * was not previosly initialized, that all key working parameters are set to
+ * thier correct initial state values (i.e. declared within a function as a
+ * normal working variable), it is required that they invoke this function
+ * before using it.
+ *
+ * @param pctxt        The pointer to the context structure variable to be
+ *                     initialized.
+ * @return             Completion status of operation:
+ *                     - 0 (ASN_OK) = success,
+ *                     - negative return value is error.
+ */
+EXTERN int initContext (OOCTXT* pctxt);
+
+/**
+ * This function frees all dynamic memory associated with a context. This
+ * includes all memory inside the block (in particular, the list of memory
+ * blocks used by the mem functions).
+ *
+ * @param pctxt       A pointer to a context structure.
+ */
+EXTERN void freeContext (OOCTXT* pctxt);
+
+/**
+ * This function allocates a new OOCTXT block and initializes it. Although
+ * the block is allocated from the standard heap, it should not be freed using
+ * free. The freeContext function should be used because this frees items
+ * allocated within the block before freeing the block itself.
+ *
+ * @return             Pointer to newly created context
+ */
+EXTERN OOCTXT* newContext (void);
+
+EXTERN void copyContext (OOCTXT* pdest, OOCTXT* psrc);
+EXTERN int  initSubContext (OOCTXT* pctxt, OOCTXT* psrc);
+EXTERN void setCtxtFlag (OOCTXT* pctxt, ASN1USINT mask);
+EXTERN void clearCtxtFlag (OOCTXT* pctxt, ASN1USINT mask);
+
+EXTERN int setPERBuffer 
+(OOCTXT* pctxt, ASN1OCTET* bufaddr, ASN1UINT bufsiz, ASN1BOOL aligned);
+
+EXTERN int setPERBufferUsingCtxt (OOCTXT* pTarget, OOCTXT* pSource);
+
+#define ZEROCONTEXT(pctxt) memset(pctxt,0,sizeof(OOCTXT))
+/** 
+ * @} cmfun
+ */
+/**
+ * @defgroup errfp Error Formatting and Print Functions 
+ * @{
+ *
+ * Error formatting and print functions allow information about the
+ * encode/decode errors to be added to a context block structure and then
+ * printed out when the error is propagated to the top level.
+ */
+
+/**
+ * This function adds an integer parameter to an error information structure.
+ * Parameter substitution is done in much the same way as it is done in C
+ * printf statments. The base error message specification that goes along with
+ * a particular status code may have variable fields built in using '%'
+ * modifiers. These would be replaced with actual parameter data.
+ *
+ * @param pErrInfo     A pointer to a structure containing information on the
+ *                     error to be printed. Typically, the error info
+ *                     structure referred to is the one inside the OOCTXT
+ *                     structure. (i.e. &pctxt->errInfo).
+ * @param errParm      The typed error parameter.
+ * @return             The status of the operation.
+ */
+EXTERN int errAddIntParm (ASN1ErrInfo* pErrInfo, int errParm);
+
+/**
+ * This function adds an string parameter to an error information structure.
+ * Parameter substitution is done in much the same way as it is done in C
+ * printf statments. The base error message specification that goes along with
+ * a particular status code may have variable fields built in using '%'
+ * modifiers. These would be replaced with actual parameter data.
+ *
+ * @param pErrInfo     A pointer to a structure containing information on the
+ *                     error to be printed. Typically, the error info
+ *                     structure referred to is the one inside the OOCTXT
+ *                     structure. (i.e. &pctxt->errInfo).
+ * @param errprm_p     The typed error parameter.
+ * @return             The status of the operation.
+ */
+EXTERN int errAddStrParm (ASN1ErrInfo* pErrInfo, 
+                            const char* errprm_p);
+
+/**
+ * This function adds an unsigned integer parameter to an error information
+ * structure. Parameter substitution is done in much the same way as it is done
+ * in C printf statments. The base error message specification that goes along
+ * with a particular status code may have variable fields built in using '%'
+ * modifiers. These would be replaced with actual parameter data.
+ *
+ * @param pErrInfo     A pointer to a structure containing information on the
+ *                     error to be printed. Typically, the error info
+ *                     structure referred to is the one inside the OOCTXT
+ *                     structure. (i.e. &pctxt->errInfo).
+ * @param errParm      The typed error parameter.
+ * @return             The status of the operation.
+ */
+EXTERN int errAddUIntParm (ASN1ErrInfo* pErrInfo, unsigned int errParm);
+
+
+EXTERN int errCopyData (ASN1ErrInfo* pSrcErrInfo, 
+                        ASN1ErrInfo* pDestErrInfo);
+
+/**
+ * This function frees memory associated with the storage of parameters
+ * associated with an error message. These parameters are maintained on an
+ * internal linked list maintained within the error information structure. The
+ * list memory must be freed when error processing is complete. This function
+ * is called from within errPrint after teh error has been printed out. It is
+ * also called in teh freeContext function.
+ *
+ * @param pErrInfo     A pointer to a structure containing information on the
+ *                     error to be printed. Typically, the error info
+ *                     structure referred to is the one inside the OOCTXT
+ *                     structure. (i.e. &pctxt->errInfo).
+ */
+EXTERN void  errFreeParms (ASN1ErrInfo* pErrInfo);
+
+
+EXTERN char* errFmtMsg (ASN1ErrInfo* pErrInfo, char* bufp);
+
+/**
+ * This function gets the text of the error
+ *
+ * @param pctxt       A pointer to a context structure.
+ */
+EXTERN char* errGetText (OOCTXT* pctxt);
+
+/**
+ * This function prints error information to the standard output device. The
+ * error information is stored in a structure of type ASN1ErrInfo. A structure
+ * of the this type is part f the OOCTXT structure. This is where error
+ * information is stored within the ASN1C generated and low-level encode/decode
+ * functions.
+ *
+ * @param pErrInfo     A pointer to a structure containing information on the
+ *                     error to be printed. Typically, the error info
+ *                     structure referred to is the one inside the OOCTXT
+ *                     structure. (i.e. &pctxt->errInfo).
+ */
+EXTERN void errPrint (ASN1ErrInfo* pErrInfo);
+
+/**
+ * This function resets the error information in the error information
+ * sturcture.
+ *
+ * @param pErrInfo     A pointer to a structure containing information on the
+ *                     error to be printed. Typically, the error info
+ *                     structure referred to is the one inside the OOCTXT
+ *                     structure. (i.e. &pctxt->errInfo).
+ */
+EXTERN int errReset (ASN1ErrInfo* pErrInfo);
+
+/** 
+ * This function sets error information in an error information structure. The
+ * information set includes status code, module name, and line number. Location
+ * information (i.e. module name and line number) is pushed onto a stack within
+ * the error information structure to provide a complete stack trace when the
+ * information is printed out.
+ *
+ * @param pErrInfo     A pointer to a structure containing information on the
+ *                     error to be printed. Typically, the error info
+ *                     structure referred to is the one inside the OOCTXT
+ *                     structure. (i.e. &pctxt->errInfo).
+ * @param status       The error status code. This is one of the negative error
+ *                     status codes.
+ * @param module       The name of the module (C or C++ source file) in which
+ *                     the module occurred. This is typically obtained by
+ *                     using the _FILE_ macro.
+ * @param lno          The line number at which the error occurred. This is
+ *                     typically obtained by using the _LINE_ macro.
+ * @return             The status value passed to the operation in the third
+ *                     argument. This makes it possible to set the error
+ *                     information and return the status value in one line of
+ *                     code.
+ */
+EXTERN int errSetData (ASN1ErrInfo* pErrInfo, int status, 
+                       const char* module, int lno);
+
+#ifndef _COMPACT
+#define LOG_ASN1ERR(ctxt,stat) \
+errSetData(&(ctxt)->errInfo,stat,__FILE__,__LINE__)
+#else
+#define LOG_ASN1ERR(ctxt,stat) \
+((ctxt)->errInfo.status = stat, stat)
+#endif
+
+
+
+#define LOG_ASN1ERR_AND_FREE(pctxt,stat,lctxt) \
+freeContext ((lctxt)), LOG_ASN1ERR(pctxt, stat)
+/** 
+ * @} 
+ */
+
+#define RT_MH_DONTKEEPFREE 0x1
+
+#define OSRTMH_PROPID_DEFBLKSIZE   1
+#define OSRTMH_PROPID_SETFLAGS     2
+#define OSRTMH_PROPID_CLEARFLAGS   3
+
+#define OSRTMH_PROPID_USER         10
+
+/**
+ * @addtogroup rtmem
+ * @{
+ */
+/**
+ * Allocate memory.  This macro allocates the given number of bytes.  It is 
+ * similar to the C \c malloc run-time function.
+ * 
+ * @param pctxt - Pointer to a context block
+ * @param nbytes - Number of bytes of memory to allocate
+ * @return - Void pointer to allocated memory or NULL if insufficient memory 
+ *   was available to fulfill the request.
+ */
+#define memAlloc(pctxt,nbytes) \
+memHeapAlloc(&(pctxt)->pTypeMemHeap,nbytes)
+
+/**
+ * Allocate and zero memory.  This macro allocates the given number of bytes
+ * and then initializes the memory block to zero.
+ * 
+ * @param pctxt - Pointer to a context block
+ * @param nbytes - Number of bytes of memory to allocate
+ * @return - Void pointer to allocated memory or NULL if insufficient memory 
+ *   was available to fulfill the request.
+ */
+#define memAllocZ(pctxt,nbytes) \
+memHeapAllocZ(&(pctxt)->pTypeMemHeap,nbytes)
+
+/**
+ * Reallocate memory.  This macro reallocates a memory block (either 
+ * expands or contracts) to the given number of bytes.  It is 
+ * similar to the C \c realloc run-time function.
+ * 
+ * @param pctxt - Pointer to a context block
+ * @param mem_p - Pointer to memory block to reallocate.  This must have been 
+ *   allocated using the memHeapAlloc macro or the memHeapAlloc function.
+ * @param nbytes - Number of bytes of memory to which the block is to be 
+ *   resized.
+ * @return - Void pointer to allocated memory or NULL if insufficient memory 
+ *   was available to fulfill the request.  This may be the same as the pmem 
+ *   pointer that was passed in if the block did not need to be relocated.
+ */
+#define memRealloc(pctxt,mem_p,nbytes) \
+memHeapRealloc(&(pctxt)->pTypeMemHeap, (void*)mem_p, nbytes)
+
+/**
+ * Free memory pointer.  This macro frees memory at the given pointer.  
+ * The memory must have been allocated using the memHeapAlloc (or similar) 
+ * macros or the mem memory allocation macros.  This macro is 
+ * similar to the C \c free function.
+ * 
+ * @param pctxt - Pointer to a context block
+ * @param mem_p - Pointer to memory block to free.  This must have 
+ *   been allocated using the memHeapAlloc or memAlloc macro or the 
+ *   memHeapAlloc function.
+ */
+#define memFreePtr(pctxt,mem_p) \
+if (memHeapCheckPtr (&(pctxt)->pTypeMemHeap, (void*)mem_p)) \
+memHeapFreePtr(&(pctxt)->pTypeMemHeap, (void*)mem_p)
+
+/**
+ * Free memory associated with a context.  This macro frees all memory 
+ * held within a context.  This is all memory allocated using the 
+ * memHeapAlloc (and similar macros) and the mem memory allocation 
+ * functions using the given context variable.
+ * 
+ * @param pctxt - Pointer to a context block
+ */
+#define memFree(pctxt) \
+memHeapFreeAll(&(pctxt)->pTypeMemHeap)
+
+/**
+ * Reset memory associated with a context.  This macro resets all memory 
+ * held within a context.  This is all memory allocated using the memHeapAlloc 
+ * (and similar macros) and the mem memory allocation functions using the 
+ * given context variable.
+ *
+ * <p>The difference between this and the ASN1MEMFREE macro is that the 
+ * memory blocks held within the context are not actually freed.  Internal 
+ * pointers are reset so the existing blocks can be reused.  This can 
+ * provide a performace improvement for repetitive tasks such as decoding 
+ * messages in a loop.
+ * 
+ * @param pctxt - Pointer to a context block
+ */
+#define memReset(pctxt) \
+memHeapReset(&(pctxt)->pTypeMemHeap)
+
+/* Alias for __cdecl modifier; if __cdecl keyword is not supported, 
+ * redefine it as empty macro. */
+
+#if !defined(OSCDECL)
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define OSCDECL __cdecl
+#else
+#define OSCDECL
+#endif
+#endif /* OSCDECL */
+
+/* Pointers to C Run-Time memory allocation functions *
+ * (See memSetAllocFuncs)                           */
+
+typedef void *(OSCDECL *OSMallocFunc ) (size_t size);
+typedef void *(OSCDECL *OSReallocFunc) (void *ptr, size_t size);
+typedef void  (OSCDECL *OSFreeFunc   ) (void *ptr);
+
+EXTERN void  memHeapAddRef (void** ppvMemHeap);
+EXTERN void* memHeapAlloc (void** ppvMemHeap, int nbytes);
+EXTERN void* memHeapAllocZ (void** ppvMemHeap, int nbytes);
+EXTERN int   memHeapCheckPtr (void** ppvMemHeap, void* mem_p);
+EXTERN int   memHeapCreate (void** ppvMemHeap);
+EXTERN void  memHeapFreeAll (void** ppvMemHeap);
+EXTERN void  memHeapFreePtr (void** ppvMemHeap, void* mem_p);
+EXTERN void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_);
+EXTERN void  memHeapRelease (void** ppvMemHeap);
+EXTERN void  memHeapReset (void** ppvMemHeap);
+
+EXTERN void* memHeapMarkSaved 
+(void** ppvMemHeap, const void* mem_p, ASN1BOOL saved);
+
+EXTERN void  memHeapSetProperty 
+(void** ppvMemHeap, ASN1UINT propId, void* pProp);
+
+
+/**
+ * This function sets the pointers to standard allocation functions. These
+ * functions are used to allocate/reallocate/free the memory blocks. By
+ * default, standard C functions - 'malloc', 'realloc' and 'free' - are used.
+ * But if some platforms do not support these functions (or some other reasons
+ * exist) they can be overloaded. The functions being overloaded should have
+ * the same prototypes as standard ones.
+ *
+ * @param malloc_func Pointer to the memory allocation function ('malloc' by
+ *    default).
+ * @param realloc_func Pointer to the memory reallocation function ('realloc'
+ *    by default).
+ * @param free_func Pointer to the memory deallocation function ('free' by
+ *    default).
+ */
+EXTERN void  memSetAllocFuncs (OSMallocFunc malloc_func,
+                               OSReallocFunc realloc_func,
+                               OSFreeFunc free_func);
+
+EXTERN void  memFreeOpenSeqExt (OOCTXT* pctxt, DList *pElemList);
+
+/*
+ * This function sets flags to a heap. May be used to control the heap's
+ * behavior.
+ *
+ * @param pctxt        Pointer to a memory block structure that contains the
+ *                     list of dynamic memory block maintained by these
+ *                     functions.
+ * @param flags        The flags.
+ */
+EXTERN void  memHeapSetFlags (OOCTXT* pctxt, ASN1UINT flags);
+
+/*
+ * This function clears memory heap flags.
+ *
+ * @param pctxt        Pointer to a memory block structure that contains the
+ *                     list of dynamic memory block maintained by these
+ *                     functions.
+ * @param flags        The flags
+ */
+EXTERN void  memHeapClearFlags (OOCTXT* pctxt, ASN1UINT flags);
+
+/**
+ * This function sets the pointer to standard allocation functions. These
+ * functions are used to allocate/reallocate/free the memory blocks. By
+ * default, standard C functions - malloc, realloc, and free - are used. But if
+ * some platforms do not support these functions or some other reasons exist)
+ * they can be overloaded. The functions being overloaded should have the same
+ * prototypes as standard ones.
+ *
+ * @param pctxt        Pointer to a context block.
+ * @param blkSize      The currently used minimum size and the granularity of
+ *                     memory blocks.
+ */
+
+EXTERN void  memHeapSetDefBlkSize (OOCTXT* pctxt, ASN1UINT blkSize);
+
+/**
+ * This function returns the actual granularity of memory blocks.
+ *
+ * @param pctxt        Pointer to a context block.
+ */
+EXTERN ASN1UINT memHeapGetDefBlkSize (OOCTXT* pctxt);
+
+#ifdef _STATIC_HEAP
+EXTERN void memSetStaticBuf (void* memHeapBuf, ASN1UINT blkSize);
+#endif
+
+/* PER encode/decode related items */
+
+#define INCRBITIDX(pctxt) \
+((--(pctxt)->buffer.bitOffset < 0) ? \
+((++(pctxt)->buffer.byteIndex >= (pctxt)->buffer.size) ? ASN_E_ENDOFBUF : \
+((pctxt)->buffer.bitOffset = 7, ASN_OK)) : ASN_OK)
+
+#define DECODEBIT(pctxt,pvalue) \
+((INCRBITIDX (pctxt) != ASN_OK) ? ASN_E_ENDOFBUF : ((pvalue) ? \
+((*(pvalue) = (((pctxt)->buffer.data[(pctxt)->buffer.byteIndex]) & \
+(1 << (pctxt)->buffer.bitOffset)) != 0), ASN_OK) : ASN_OK ))
+
+/*
+#define SETCHARSET(csetvar, canset, abits, ubits) \
+csetvar.charSet.nchars = 0; \
+csetvar.canonicalSet = canset; \
+csetvar.canonicalSetSize = sizeof(canset)-1; \
+csetvar.canonicalSetBits = getUIntBitCount(csetvar.canonicalSetSize); \
+csetvar.charSetUnalignedBits = ubits; \
+csetvar.charSetAlignedBits = abits;
+*/
+
+/**
+ * This function will decode a series of multiple bits and place the results in
+ * an unsigned integer variable.
+ *
+ * @param pctxt       A pointer to a context structure. This provides a
+ *                    storage area for the function to store all working
+ *                    variables that must be maintained between function
+ *                    calls.
+ * @param pvalue      A pointer to an unsigned integer variable to receive the
+ *                    decoded result.
+ * @param nbits       The number of bits to decode.
+ * @return            Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeBits 
+(OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT nbits);
+
+/**
+ * This function will decode a value of the ASN.1 bit string type whose maximum
+ * size is is known in advance. The ASN1C complier generates a call to this
+ * function to decode bit string productions or elements that contain a size
+ * constraint.
+ *
+ * @param pctxt       A pointer to a context structure. This provides a
+ *                    storage area for the function to store all working
+ *                    variables that must be maintained between function
+ *                    calls.
+ * @param numbits_p   Pointer to an unsigned integer variable to receive
+ *                    decoded number of bits.
+ * @param buffer      Pointer to a fixed-size or pre-allocated array of bufsiz
+ *                    octets to receive a decoded bit string.
+ * @param bufsiz      Length (in octets) of the buffer to receive the decoded
+ *                    bit string.
+ * @return            Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeBitString 
+(OOCTXT* pctxt, ASN1UINT* numbits_p, ASN1OCTET* buffer,
+ ASN1UINT bufsiz);
+
+/**
+ * This function will decode a variable of the ASN.1 BMP character string. This
+ * differs from the decode routines for the character strings previously
+ * described in that the BMP string type is based on 16-bit characters. A
+ * 16-bit character string is modeled using an array of unsigned short
+ * integers.
+ *
+ * @param pctxt       A pointer to a context structure. This provides a
+ *                    storage area for the function to store all working
+ *                    variables that must be maintained between function
+ *                    calls.
+ * @param pvalue      Pointer to character string structure to receive the
+ *                    decoded result The structure includes a count field
+ *                    containing the number of characters and an array of
+ *                    unsigned short integers to hold the 16-bit character
+ *                    values.
+ * @param permCharSet A pointer to the constraining character set. This
+ *                    contains an array containing all valid characters in
+ *                    the set as well as the aligned and unaligned bit
+ *                    counts required to encode the characters.
+ * @return            Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeBMPString 
+(OOCTXT* pctxt, ASN1BMPString* pvalue, Asn116BitCharSet* permCharSet);
+
+/**
+ * This function will position the decode bit cursor on the next byte boundary.
+ *
+ * @param pctxt       A pointer to a context structure. This provides a
+ *                    storage area for the function to store all working
+ *                    variables that must be maintained between function
+ *                    calls.
+ * @return            Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeByteAlign (OOCTXT* pctxt);
+
+/**
+ * This function will decode an integer constrained either by a value or value
+ * range constraint.
+ *
+ * @param pctxt       Pointer to context block structure.
+ * @param pvalue      Pointer to integer variable to receive decoded value.
+ * @param lower       Lower range value.
+ * @param upper       Upper range value.
+ * @return            Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeConsInteger 
+(OOCTXT* pctxt, ASN1INT* pvalue, ASN1INT lower, ASN1INT upper);
+
+/**
+ * This function will decode an unsigned integer constrained either by a value
+ * or value range constraint.
+ *
+ * @param pctxt       Pointer to context block structure.
+ * @param pvalue      Pointer to unsigned integer variable to receive decoded
+ *                    value.
+ * @param lower       Lower range value.
+ * @param upper       Upper range value.
+ * @return            Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeConsUnsigned 
+(OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT lower, ASN1UINT upper);
+
+/**
+ * This function will decode an 8-bit unsigned integer constrained either by a
+ * value or value range constraint.
+ *
+ * @param pctxt       Pointer to context block structure.
+ * @param pvalue      Pointer to 8-bit unsigned integer variable to receive
+ *                    decoded value.
+ * @param lower       Lower range value.
+ * @param upper       Upper range value.
+ * @return            Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeConsUInt8 (OOCTXT* pctxt, 
+                            ASN1UINT8* pvalue, ASN1UINT lower, ASN1UINT upper);
+
+/**
+ * This function will decode a 16-bit unsigned integer constrained either by a
+ * value or value range constraint.
+ *
+ * @param pctxt       Pointer to context block structure.
+ * @param pvalue      Pointer to 16-bit unsigned integer variable to receive
+ *                    decoded value.
+ * @param lower       Lower range value.
+ * @param upper       Upper range value.
+ * @return            Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeConsUInt16 
+(OOCTXT* pctxt, ASN1USINT* pvalue, ASN1UINT lower, ASN1UINT upper);
+
+/**
+ * This function decodes a constrained whole number as specified in Section
+ * 10.5 of the X.691 standard.
+ *
+ * @param pctxt             Pointer to context block structure.
+ * @param padjusted_value   Pointer to unsigned adjusted integer value to
+ *                          receive decoded result. To get the final value,
+ *                          this value is added to the lower boundary of the
+ *                          range.
+ * @param range_value       Unsigned integer value specifying the total size
+ *                          of the range. This is obtained by subtracting
+ *                          the lower range value from the upper range
+ *                          value.
+ * @return                  Completion status of operation:
+ *                             - 0 (ASN_OK) = success,
+ *                             - negative return value is error.
+ */
+EXTERN int decodeConsWholeNumber 
+(OOCTXT* pctxt, ASN1UINT* padjusted_value, ASN1UINT range_value);
+
+/**
+ * This function decodes a constrained string value. This version of the
+ * function allows all of the required permitted alphabet constraint parameters
+ * to be passed in as arguments.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param string       Pointer to const char* to receive decoded string. Memory
+ *                     will be allocated for this variable using internal
+ *                     memory management functions.
+ * @param charSet      String containing permitted alphabet character set. Can
+ *                     be null if no character set was specified.
+ * @param abits        Number of bits in a character set character (aligned).
+ * @param ubits        Number of bits in a character set character (unaligned).
+ * @param canSetBits   Number of bits in a character from the canonical set
+ *                     representing this string.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeConstrainedStringEx 
+(OOCTXT* pctxt, const char** string, const char* charSet,
+ ASN1UINT abits, ASN1UINT ubits, ASN1UINT canSetBits);
+
+/**
+ * This function will decode a variable of thr ASN.1 BIT STRING type. This
+ * function allocates dynamic memory t store the decoded result. The ASN1C
+ * complier generates a call to this function to decode an unconstrained bit
+ * string production or element.
+ *
+ * @param pctxt       A pointer to a context structure. This provides a
+ *                       storage area for the function to store all working
+ *                       variables that must be maintained between function
+ *                       calls.
+ * @param pBitStr      Pointer to a dynamic bit string structure to receive the
+ *                       decoded result. This structure contains a field to
+ *                       hold the number of decoded bits and a pointer to an
+ *                       octet string to hold the decoded data. Memory is
+ *                       allocated by the decoder using the memAlloc
+ *                       function. This memory is tracked within the context
+ *                       and released when the freeContext function is
+ *                       invoked.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeDynBitString (OOCTXT* pctxt, ASN1DynBitStr* pBitStr);
+
+/**
+ * This function will decode a value of the ASN.1 octet string type whose
+ * maximum size is known in advance. The ASN1C complier generates a call to
+ * this function to decode octet string productions or elements that contain a
+ * size constraint.
+ *
+ * @param pctxt       A pointer to a context structure. This provides a
+ *                       storage area for the function to store all working
+ *                       variables that must be maintained between function
+ *                       calls.
+ * @param pOctStr      A pointer to a dynamic octet string to receive the
+ *                       decoded result.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeDynOctetString 
+(OOCTXT* pctxt, ASN1DynOctStr* pOctStr);
+
+/**
+ * This function will decode a length determinant value.
+ *
+ * @param pctxt       A pointer to a context structure. This provides a
+ *                       storage area for the function to store all working
+ *                       variables that must be maintained between function
+ *                       calls.
+ * @param pvalue       A pointer to an unsigned integer variable to receive the
+ *                       decoded length value.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeLength (OOCTXT* pctxt, ASN1UINT* pvalue);
+
+/**
+ * @param pctxt       A pointer to a context structure. This provides a
+ *                       storage area for the function to store all working
+ *                       variables that must be maintained between function
+ *                       calls.
+ * @param bitOffset    The bit offset inside the message buffer.
+ */
+EXTERN int moveBitCursor (OOCTXT* pctxt, int bitOffset);
+
+/**
+ * This function decodes a value of the ASN.1 object identifier type.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param pvalue       Pointer to value to receive decoded result. The
+ *                       ASN1OBJID structure contains an integer to hold the
+ *                       number of subidentifiers and an array to hold the
+ *                       subidentifier values.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeObjectIdentifier (OOCTXT* pctxt, ASN1OBJID* pvalue);
+
+/**
+ * This function will decode a value of the ASN.1 octet string type whose
+ * maximun size is known in advance. The ASN1C compiler generates a call to
+ * this function to decode octet string productions or elements that contain a
+ * size constraint.
+ *
+ * @param pctxt        Pointer to a context structure. This provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param numocts_p    A pointer to an unsigned buffer of bufsiz octets to
+ *                       receive decoded data.
+ * @param buffer       A pointer to a pre-allocated buffer of size octets to
+ *                       receive the decoded data.
+ * @param bufsiz       The size of the buffer to receive the decoded result.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeOctetString 
+(OOCTXT* pctxt, ASN1UINT* numocts_p, ASN1OCTET* buffer,
+ ASN1UINT bufsiz);
+
+/**
+ * This function will decode an ASN.1 open type. This used to be the ASN.1 ANY
+ * type, but now is used in a variety of applications requiring an encoding 
+ * that can be interpreted by a decoder without prior knowledge of the type 
+ * of the variable.
+ *
+ * @param pctxt        Pointer to a context structure. This provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param numocts_p    A pointer to an unsigned buffer of bufsiz octets to
+ *                       receive decoded data.
+ * @param object_p2    A pointer to an open type variable to receive the
+ *                       decoded data.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeOpenType 
+(OOCTXT* pctxt, const ASN1OCTET** object_p2, ASN1UINT* numocts_p);
+
+/**
+ * This function will decode a small non-negative whole number as specified in
+ * Section 10.6 of the X.691 standard. This is a number that is expected to be
+ * small, but whose size is potentially unlimited due to the presence of an
+ * extension maker.
+ *
+ * @param pctxt        Pointer to a context structure. This provides a storage
+ *                       area for the function to store all workings variables
+ *                       that must be maintained between function calls.
+ * @param pvalue       Pointer to an unsigned integer value t receive decoded
+ *                       results.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeSmallNonNegWholeNumber 
+(OOCTXT* pctxt, ASN1UINT* pvalue);
+
+/**
+ * This function will decode a semi-constrained integer.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param pvalue       Pointer to integer variable to receive decoded value.
+ * @param lower        Lower range value, represented as signed
+ *                       integer.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeSemiConsInteger 
+   (OOCTXT* pctxt, ASN1INT* pvalue, ASN1INT lower);
+
+/**
+ * This function will decode a semi-constrained unsigned integer.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param pvalue       Pointer to unsigned integer variable to receive decoded
+ *                       value.
+ * @param lower        Lower range value, represented as unsigned
+ *                       integer.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int decodeSemiConsUnsigned 
+   (OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT lower);
+
+/**
+ * This function will decode an unconstrained integer.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param pvalue       Pointer to integer variable to receive decoded value.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+#define decodeUnconsInteger(pctxt,pvalue) \
+decodeSemiConsInteger(pctxt, pvalue, ASN1INT_MIN)
+
+/**
+ * This function will decode an unconstrained unsigned integer.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param pvalue       Pointer to unsigned integer variable to receive decoded
+ *                       value.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+#define decodeUnconsUnsigned(pctxt,pvalue) \
+decodeSemiConsUnsigned(pctxt, pvalue, 0U)
+
+EXTERN int decodeVarWidthCharString (OOCTXT* pctxt, const char** pvalue);
+
+/**
+ * This function will encode a variable of the ASN.1 BOOLEAN type in 
+ * a single bit.
+ *
+ * @param pctxt        Pointer to a context structure. This provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param value        The BOOLEAN value to be encoded.
+ */
+EXTERN int encodeBit (OOCTXT* pctxt, ASN1BOOL value);
+
+/**
+ * This function encodes multiple bits.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param value        Unsigned integer containing the bits to be encoded.
+ * @param nbits        Number of bits in value to encode.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeBits 
+(OOCTXT* pctxt, ASN1UINT value, ASN1UINT nbits);
+
+/**
+ * This function will encode a value of the ASN.1 bit string type.
+ *
+ * @param pctxt        A pointer to a context structure. This provides a
+ *                       storage area for the function to store all working
+ *                       variables that must be maintained between function
+ *                       calls.
+ * @param numocts      The number of bits n the string to be encoded.
+ * @param data         Pointer to the bit string data to be encoded.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeBitString 
+(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data);
+
+/**
+ * This function will encode a variable of the ASN.1 BMP character string. This
+ * differs from the encode routines for the character strings previously
+ * described in that the BMP string type is based on 16-bit characters. A
+ * 16-bit character string is modeled using an array of unsigned short
+ * integers.
+ *
+ * @param pctxt        A pointer to a context structure. This provides a
+ *                       storage area for the function to store all working
+ *                       variables that must be maintained between function
+ *                       calls.
+ * @param value        Character string to be encoded. This structure includes
+ *                       a count field containing the number of characters to
+ *                       encode and an array of unsigned short integers to hold
+ *                       the 16-bit characters to be encoded.
+ * @param permCharSet  Pointer to the constraining character set. This contains
+ *                       an array containing all valid characters in the set as
+ *                       well as the aligned and unaligned bit counts required
+ *                       to encode the characters.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeBMPString 
+(OOCTXT* pctxt, ASN1BMPString value, Asn116BitCharSet* permCharSet);
+
+/**
+ * This function will position the encode bit cursor on the next byte boundry.
+ *
+ * @param pctxt        A pointer to a context structure. This provides a
+ *                       storage area for the function to store all working
+ *                       variables that must be maintained between function
+ *                       calls.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeByteAlign (OOCTXT* pctxt);
+
+/**
+ * This function will determine if the given number of bytes will fit in the
+ * encode buffer. If not, either the buffer is expanded (if it is a dynamic
+ * buffer) or an error is signaled.
+ *
+ * @param pctxt        A pointer to a context structure. This provides a
+ *                       storage area for the function to store all working
+ *                       variables that must be maintained between function
+ *                       calls.
+ * @param nbytes       Number of bytes of space required to hold the variable
+ *                       to be encoded.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeCheckBuffer (OOCTXT* pctxt, ASN1UINT nbytes);
+
+/**
+ * This function encodes a constrained string value. This version of the
+ * function allows all of the required permitted alphabet constraint parameters
+ * to be passed in as arguments.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param string       Pointer to string to be encoded.
+ * @param charSet      String containing permitted alphabet character set. Can
+ *                       be null if no character set was specified.
+ * @param abits        Number of bits in a character set character (aligned).
+ * @param ubits        Number of bits in a character set character (unaligned).
+ * @param canSetBits   Number of bits in a character from the canonical set
+ *                       representing this string.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeConstrainedStringEx 
+(OOCTXT* pctxt, const char* string, const char* charSet,
+ ASN1UINT abits, ASN1UINT ubits, ASN1UINT canSetBits);
+
+/**
+ * This function encodes an integer constrained either by a value or value
+ * range constraint.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param value        Value to be encoded.
+ * @param lower        Lower range value.
+ * @param upper        Upper range value.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeConsInteger 
+(OOCTXT* pctxt, ASN1INT value, ASN1INT lower, ASN1INT upper);
+
+/**
+ * This function encodes an unsigned integer constrained either by a value or
+ * value range constraint. The constrained unsigned integer option is used if:
+ *
+ * 1. The lower value of the range is >= 0, and 2. The upper value of the range
+ * is >= MAXINT
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param value        Value to be encoded.
+ * @param lower        Lower range value.
+ * @param upper        Upper range value.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeConsUnsigned 
+(OOCTXT* pctxt, ASN1UINT value, ASN1UINT lower, ASN1UINT upper);
+
+/**
+ * This function encodes a constrained whole number as specified in Section
+ * 10.5 of the X.691 standard.
+ *
+ * @param pctxt             Pointer to context block structure.
+ * @param adjusted_value    Unsigned adjusted integer value to be encoded. The
+ *                            adjustment is done by subtracting the lower value
+ *                            of the range from the value to be encoded.
+ * @param range_value       Unsigned integer value specifying the total size of
+ *                            the range. This is obtained by subtracting the
+ *                            lower range value from the upper range value.
+ * @return                  Completion status of operation:
+ *                            - 0 (ASN_OK) = success,
+ *                            - negative return value is error.
+ */
+EXTERN int encodeConsWholeNumber 
+(OOCTXT* pctxt, ASN1UINT adjusted_value, ASN1UINT range_value);
+
+/**
+ * This function will expand the buffer to hold the given number of bytes.
+ *
+ * @param pctxt        Pointer to a context structure. This provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param nbytes       The number of bytes the buffer is to be expanded by.
+ *                       Note that the buffer will be expanded by
+ *                       ASN_K_ENCBIFXIZ or nbytes (whichever is larger.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeExpandBuffer (OOCTXT* pctxt, ASN1UINT nbytes);
+
+/**
+ * This function will return the message pointer and length of an encoded
+ * message. This function is called after a complier generated encode function
+ * to get the pointer and length of the message. It is normally used when
+ * dynamic encoding is specified because the message pointer is not known until
+ * encoding is complete. If static encoding is used, the message starts at the
+ * beginning of the specified buffer adn the encodeGetMsgLen function can be 
+ * used to obtain the lenght of the message.
+ *
+ * @param pctxt        Pointer to a context structure. This provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param pLength      Pointer to variable to receive length of the encoded
+ *                       message.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN ASN1OCTET* encodeGetMsgPtr (OOCTXT* pctxt, int* pLength);
+
+/**
+ * This function will encode a length determinant value.
+ *
+ * @param pctxt        Pointer to a context structure. This provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param value        Length value to be encoded.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeLength (OOCTXT* pctxt, ASN1UINT value);
+
+/**
+ * This function encodes a value of the ASN.1 object identifier type.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param pvalue       Pointer to value to be encoded. The ASN1OBJID structure
+ *                       contains a numids fields to hold the number of
+ *                       subidentifiers and an array to hold the subidentifier
+ *                       values.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeObjectIdentifier (OOCTXT* pctxt, ASN1OBJID* pvalue);
+
+
+/**
+ *
+ *  This function encodes bits from a given octet to the output buffer.
+ *
+ *  @param pctxt      Pointer to ASN.1 PER context structure
+ *  @param value      Value of bits to be encoded
+ *  @param nbits      Number of bits to be encoded
+ *
+ *  @return           Status of operation
+ */
+EXTERN int encodebitsFromOctet (OOCTXT* pctxt, ASN1OCTET value, ASN1UINT nbits);
+
+/**
+ * This fuction will encode an array of octets. The Octets will be encoded
+ * unaligned starting at the current bit offset within the encode buffer.
+ *
+ * @param pctxt        A pointer to a context structure. The provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param pvalue       A pointer to an array of octets to encode
+ * @param nbits        The number of Octets to encode
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeOctets 
+(OOCTXT* pctxt, const ASN1OCTET* pvalue, ASN1UINT nbits);
+
+/**
+ * This function will encode a value of the ASN.1 octet string type.
+ *
+ * @param pctxt        A pointer to a context structure. The provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param numocts      Number of octets in the string to be encoded.
+ * @param data         Pointer to octet string data to be encoded.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeOctetString 
+(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data);
+
+/**
+ * This function will encode an ASN.1 open type. This used to be the ANY type,
+ * but now is used in a variety of applications requiring an encoding that can
+ * be interpreted by a decoder without a prior knowledge of the type of the
+ * variable.
+ *
+ * @param pctxt        A pointer to a context structure. The provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param numocts      Number of octets in the string to be encoded.
+ * @param data         Pointer to octet string data to be encoded.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeOpenType 
+(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data);
+
+/**
+ * This function will encode an ASN.1 open type extension. An open type
+ * extension field is the data that potentially resides after the ... marker in
+ * a version-1 message. The open type structure contains a complete encoded bit
+ * set including option element bits or choice index, length, and data.
+ * Typically, this data is populated when a version-1 system decodes a
+ * version-2 message. The extension fields are retained and can then be
+ * re-encoded if a new message is to be sent out (for example, in a store and
+ * forward system).
+ *
+ * @param pctxt        A pointer to a context structure. The provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param pElemList    A pointer to the open type to be encoded.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeOpenTypeExt 
+(OOCTXT* pctxt, DList* pElemList);
+
+EXTERN int encodeOpenTypeExtBits 
+(OOCTXT* pctxt, DList* pElemList);
+
+/**
+ * This function will endcode a small, non-negative whole number as specified
+ * in Section 10.6 of teh X.691 standard. This is a number that is expected to
+ * be small, but whose size is potentially unlimited due to the presence of an
+ * extension marker.
+ *
+ * @param pctxt        A pointer to a context structure. The provides a storage
+ *                       area for the function to store all working variables
+ *                       that must be maintained between function calls.
+ * @param value        An unsigned integer value to be encoded.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeSmallNonNegWholeNumber (OOCTXT* pctxt, ASN1UINT value);
+
+/**
+ * This function encodes a semi-constrained integer.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param value        Value to be encoded.
+ * @param lower        Lower range value, represented as signed
+ *                       integer.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeSemiConsInteger 
+   (OOCTXT* pctxt, ASN1INT value, ASN1INT lower);
+
+/**
+ * This function encodes an semi-constrained unsigned integer.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param value        Value to be encoded.
+ * @param lower        Lower range value, represented as unsigned
+ *                       integer.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+EXTERN int encodeSemiConsUnsigned 
+   (OOCTXT* pctxt, ASN1UINT value, ASN1UINT lower);
+
+/**
+ * This function encodes an unconstrained integer.
+ *
+ * @param pctxt        Pointer to context block structure.
+ * @param value        Value to be encoded.
+ * @return             Completion status of operation:
+ *                       - 0 (ASN_OK) = success,
+ *                       - negative return value is error.
+ */
+#define encodeUnconsInteger(pctxt,value) \
+encodeSemiConsInteger(pctxt,value,ASN1INT_MIN)
+
+EXTERN int encodeVarWidthCharString (OOCTXT* pctxt, const char* value); 
+
+EXTERN int addSizeConstraint (OOCTXT* pctxt, Asn1SizeCnst* pSize);
+
+EXTERN ASN1BOOL alignCharStr 
+(OOCTXT* pctxt, ASN1UINT len, ASN1UINT nbits, Asn1SizeCnst* pSize);
+
+EXTERN int bitAndOctetStringAlignmentTest 
+(Asn1SizeCnst* pSizeList, ASN1UINT itemCount, 
+ ASN1BOOL bitStrFlag, ASN1BOOL* pAlignFlag);
+
+EXTERN int getPERMsgLen (OOCTXT* pctxt);
+
+EXTERN int addSizeConstraint (OOCTXT* pctxt, Asn1SizeCnst* pSize);
+
+EXTERN Asn1SizeCnst* getSizeConstraint (OOCTXT* pctxt, ASN1BOOL extbit);
+
+EXTERN int checkSizeConstraint(OOCTXT* pctxt, int size);
+EXTERN ASN1UINT getUIntBitCount (ASN1UINT value);
+
+EXTERN Asn1SizeCnst* checkSize 
+(Asn1SizeCnst* pSizeList, ASN1UINT value, ASN1BOOL* pExtendable);
+
+EXTERN void init16BitCharSet 
+(Asn116BitCharSet* pCharSet, ASN116BITCHAR first,
+ ASN116BITCHAR last, ASN1UINT abits, ASN1UINT ubits);
+
+EXTERN ASN1BOOL isExtendableSize (Asn1SizeCnst* pSizeList);
+
+EXTERN void set16BitCharSet 
+(OOCTXT* pctxt, Asn116BitCharSet* pCharSet, Asn116BitCharSet* pAlphabet);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif 
diff --git a/addons/ooh323c/src/oochannels.c b/addons/ooh323c/src/oochannels.c
new file mode 100644
index 000000000..8fe8c60cd
--- /dev/null
+++ b/addons/ooh323c/src/oochannels.c
@@ -0,0 +1,1785 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooports.h" 
+#include "oochannels.h"
+#include "ootrace.h"
+#include "ooq931.h"
+#include "ooh245.h"
+#include "ooh323.h"
+#include "ooCalls.h"
+#include "printHandler.h"
+#include "ooGkClient.h"
+#include "stdio.h"
+#include "ooTimer.h"
+#include "ooh323ep.h"
+#include "ooStackCmds.h"
+#include "ooCmdChannel.h"
+#include "ootypes.h"
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+extern DList g_TimerList;
+
+static OOBOOL gMonitor = FALSE;
+
+
+int ooCreateH245Listener(OOH323CallData *call)
+{
+   int ret=0;
+   OOSOCKET channelSocket=0;
+   OOTRACEINFO1("Creating H245 listener\n");
+   if((ret=ooSocketCreate (&channelSocket))!=ASN_OK)
+   {
+      OOTRACEERR3("ERROR: Failed to create socket for H245 listener "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ret = ooBindPort (OOTCP, channelSocket, call->localIP); 
+   if(ret == OO_FAILED)
+   {
+      OOTRACEERR3("Error:Unable to bind to a TCP port - H245 listener creation"
+                  " (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   call->h245listenport = (int*) memAlloc(call->pctxt, sizeof(int));
+   *(call->h245listenport) = ret;
+   call->h245listener = (OOSOCKET*)memAlloc(call->pctxt, sizeof(OOSOCKET));
+   *(call->h245listener) = channelSocket;
+   ret = ooSocketListen(*(call->h245listener), 20);
+   if(ret != ASN_OK)
+   {
+      OOTRACEERR3("Error:Unable to listen on H.245 socket (%s, %s)\n", 
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   
+   OOTRACEINFO4("H245 listener creation - successful(port %d) (%s, %s)\n", 
+                *(call->h245listenport),call->callType, call->callToken);
+   return OO_OK;
+}
+
+int ooCreateH245Connection(OOH323CallData *call)
+{
+   int ret=0;
+   OOSOCKET channelSocket=0;
+   ooTimerCallback *cbData=NULL;
+
+   OOTRACEINFO1("Creating H245 Connection\n");
+   if((ret=ooSocketCreate (&channelSocket))!=ASN_OK)
+   {
+      OOTRACEERR3("ERROR:Failed to create socket for H245 connection "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   else
+   {
+      if (0 == call->pH245Channel) {
+         call->pH245Channel = 
+            (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel));
+      }
+
+      /*
+         bind socket to a port before connecting. Thus avoiding
+         implicit bind done by a connect call.
+      */
+      ret = ooBindPort(OOTCP, channelSocket, call->localIP); 
+      if(ret == OO_FAILED)
+      {
+         OOTRACEERR3("Error:Unable to bind to a TCP port - h245 connection "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      call->pH245Channel->port = ret;
+      OOTRACEDBGC4("Local H.245 port is %d (%s, %s)\n", 
+                   call->pH245Channel->port,
+                   call->callType, call->callToken);
+      OOTRACEINFO5("Trying to connect to remote endpoint to setup H245 "
+                   "connection %s:%d(%s, %s)\n", call->remoteIP, 
+                    call->remoteH245Port, call->callType, call->callToken);
+              
+      if((ret=ooSocketConnect(channelSocket, call->remoteIP,
+                              call->remoteH245Port))==ASN_OK)
+      {
+         call->pH245Channel->sock = channelSocket;
+         call->h245SessionState = OO_H245SESSION_ACTIVE;
+
+         OOTRACEINFO3("H245 connection creation succesful (%s, %s)\n",
+                      call->callType, call->callToken);
+
+         /*Start terminal capability exchange and master slave determination */
+         ret = ooSendTermCapMsg(call);
+         if(ret != OO_OK)
+         {
+            OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n",
+                         call->callType, call->callToken);
+            return ret;
+         }
+         ret = ooSendMasterSlaveDetermination(call);
+         if(ret != OO_OK)
+         {
+            OOTRACEERR3("ERROR:Sending Master-slave determination message "
+                        "(%s, %s)\n", call->callType, call->callToken);
+            return ret;
+         }
+      }
+      else
+      {
+         if(call->h245ConnectionAttempts >= 3)
+         {
+            OOTRACEERR3("Error:Failed to setup an H245 connection with remote "
+                        "destination. (%s, %s)\n", call->callType, 
+                         call->callToken);
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+               call->callState = OO_CALL_CLEAR;
+            }
+            return OO_FAILED;
+         }
+         else{
+            OOTRACEWARN4("Warn:Failed to connect to remote destination for "
+                         "H245 connection - will retry after %d seconds"
+                         "(%s, %s)\n", DEFAULT_H245CONNECTION_RETRYTIMEOUT,
+                         call->callType, call->callToken);
+
+            cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                     sizeof(ooTimerCallback));
+            if(!cbData)
+            {
+               OOTRACEERR3("Error:Unable to allocate memory for timer "
+                           "callback.(%s, %s)\n", call->callType, 
+                            call->callToken);
+               return OO_FAILED;
+            }
+            cbData->call = call;
+            cbData->timerType = OO_H245CONNECT_TIMER;
+            if(!ooTimerCreate(call->pctxt, &call->timerList, 
+                              &ooCallH245ConnectionRetryTimerExpired, 
+                              DEFAULT_H245CONNECTION_RETRYTIMEOUT, cbData, 
+                              FALSE))
+            {
+               OOTRACEERR3("Error:Unable to create H245 connection retry timer"
+                           "(%s, %s)\n", call->callType, call->callToken);
+               memFreePtr(call->pctxt, cbData);
+               return OO_FAILED;
+            }
+            return OO_OK;
+         }
+      }
+   }
+   return OO_OK;
+}
+
+int ooSendH225Msg(OOH323CallData *call, Q931Message *msg)
+{
+   int iRet=0;
+   ASN1OCTET * encodebuf;
+   if(!call)
+      return OO_FAILED;
+
+   encodebuf = (ASN1OCTET*) memAlloc (call->pctxt, MAXMSGLEN);
+   if(!encodebuf)
+   {
+      OOTRACEERR3("Error:Failed to allocate memory for encoding H225 "
+                  "message(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   iRet = ooEncodeH225Message(call, msg, encodebuf, MAXMSGLEN);
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to encode H225 message. (%s, %s)\n", 
+                  call->callType, call->callToken);
+      memFreePtr (call->pctxt, encodebuf);
+      return OO_FAILED;
+   }
+
+   /* If high priority messages, send immediately.*/
+   if(encodebuf[0] == OOReleaseComplete || 
+      (encodebuf[0]==OOFacility && encodebuf[1]==OOEndSessionCommand))
+   {
+      dListFreeAll(call->pctxt, &call->pH225Channel->outQueue);
+      dListAppend (call->pctxt, &call->pH225Channel->outQueue, encodebuf);
+      // ooSendMsg(call, OOQ931MSG);
+   }
+   else{
+      dListAppend (call->pctxt, &call->pH225Channel->outQueue, encodebuf);
+ 
+      OOTRACEDBGC4("Queued H225 messages %d. (%s, %s)\n", 
+                                     call->pH225Channel->outQueue.count, 
+                                     call->callType, call->callToken);  
+   }
+   return OO_OK;
+}
+
+int ooCreateH225Connection(OOH323CallData *call)
+{
+   int ret=0;
+   OOSOCKET channelSocket=0;
+   if((ret=ooSocketCreate (&channelSocket))!=ASN_OK)
+   {
+      OOTRACEERR3("Failed to create socket for transmit H2250 channel (%s, %s)"
+                  "\n", call->callType, call->callToken);
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callState = OO_CALL_CLEAR;
+         call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+      }
+      return OO_FAILED;
+   }
+   else
+   {
+      /*
+         bind socket to a port before connecting. Thus avoiding
+         implicit bind done by a connect call. Avoided on windows as 
+         windows sockets have problem in reusing the addresses even after
+         setting SO_REUSEADDR, hence in windows we just allow os to bind
+         to any random port.
+      */
+#ifndef _WIN32
+      ret = ooBindPort(OOTCP,channelSocket, call->localIP); 
+#else
+      ret = ooBindOSAllocatedPort(channelSocket, call->localIP);
+#endif
+      
+      if(ret == OO_FAILED)
+      {
+         OOTRACEERR3("Error:Unable to bind to a TCP port (%s, %s)\n", 
+         call->callType, call->callToken);
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callState = OO_CALL_CLEAR;
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+         }
+         return OO_FAILED;
+      }
+
+      if (0 == call->pH225Channel) {
+         call->pH225Channel = 
+            (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel));
+      }
+      call->pH225Channel->port = ret;
+
+      OOTRACEINFO5("Trying to connect to remote endpoint(%s:%d) to setup "
+                   "H2250 channel (%s, %s)\n", call->remoteIP, 
+                   call->remotePort, call->callType, call->callToken);
+
+      if((ret=ooSocketConnect(channelSocket, call->remoteIP,
+                              call->remotePort))==ASN_OK)
+      {
+         call->pH225Channel->sock = channelSocket;
+
+         OOTRACEINFO3("H2250 transmiter channel creation - succesful "
+                      "(%s, %s)\n", call->callType, call->callToken);
+
+         /* If multihomed, get ip from socket */
+         if(!strcmp(call->localIP, "0.0.0.0"))
+         {
+            OOTRACEDBGA3("Determining IP address for outgoing call in "
+                         "multihomed mode. (%s, %s)\n", call->callType, 
+                          call->callToken);
+            ret = ooSocketGetIpAndPort(channelSocket, call->localIP, 20, 
+                                       &call->pH225Channel->port);
+            if(ret != ASN_OK)
+            {
+               OOTRACEERR3("ERROR:Failed to retrieve local ip and port from "
+                           "socket for multihomed mode.(%s, %s)\n", 
+                            call->callType, call->callToken);
+               if(call->callState < OO_CALL_CLEAR)
+               {  /* transport failure */
+                  call->callState = OO_CALL_CLEAR;
+                  call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+               }
+               return OO_FAILED;
+            }
+            OOTRACEDBGA4("Using local ip %s for outgoing call(multihomedMode)."
+                         " (%s, %s)\n", call->localIP, call->callType, 
+                         call->callToken);
+         }
+         return OO_OK;
+      }
+      else
+      {
+         OOTRACEERR3("ERROR:Failed to connect to remote destination for "
+                    "transmit H2250 channel(%s, %s)\n",call->callType,
+                     call->callToken);
+         if(call->callState < OO_CALL_CLEAR)
+         {  /* No one is listening at remote end */
+            call->callState = OO_CALL_CLEAR;
+            call->callEndReason = OO_REASON_NOUSER;
+         }
+         return OO_FAILED;
+      }
+
+      return OO_FAILED;
+   }
+}
+
+int ooCloseH225Connection (OOH323CallData *call)
+{
+   if (0 != call->pH225Channel)
+   {
+      if(call->pH225Channel->sock != 0)
+         ooSocketClose (call->pH225Channel->sock);
+      if (call->pH225Channel->outQueue.count > 0)
+      {
+         dListFreeAll (call->pctxt, &(call->pH225Channel->outQueue));
+      }
+      memFreePtr (call->pctxt, call->pH225Channel);
+      call->pH225Channel = NULL;
+   }
+   return OO_OK;
+}
+
+int ooCreateH323Listener()
+{
+   int ret=0;
+   OOSOCKET channelSocket=0;
+   OOIPADDR ipaddrs;
+
+    /* Create socket */
+   if((ret=ooSocketCreate (&channelSocket))!=ASN_OK)
+   {
+      OOTRACEERR1("Failed to create socket for H323 Listener\n");
+      return OO_FAILED;
+   }
+   ret= ooSocketStrToAddr (gH323ep.signallingIP, &ipaddrs);
+   if((ret=ooSocketBind (channelSocket, ipaddrs, 
+                         gH323ep.listenPort))==ASN_OK) 
+   {
+      gH323ep.listener = (OOSOCKET*)memAlloc(&gH323ep.ctxt,sizeof(OOSOCKET));
+      *(gH323ep.listener) = channelSocket;
+          
+      ooSocketListen(channelSocket,20); /*listen on socket*/
+      OOTRACEINFO1("H323 listener creation - successful\n");
+      return OO_OK;
+   }
+   else
+   {
+      OOTRACEERR1("ERROR:Failed to create H323 listener\n");
+      return OO_FAILED;
+   }
+}
+
+
+
+int ooAcceptH225Connection()    
+{
+   OOH323CallData * call;
+   int ret;
+   char callToken[20];
+   OOSOCKET h225Channel=0;
+   ret = ooSocketAccept (*(gH323ep.listener), &h225Channel, 
+                         NULL, NULL);
+   if(ret != ASN_OK)
+   {
+      OOTRACEERR1("Error:Accepting h225 connection\n");
+      return OO_FAILED;
+   }
+   ooGenerateCallToken(callToken, sizeof(callToken));
+
+   call = ooCreateCall("incoming", callToken);
+   if(!call)
+   {
+      OOTRACEERR1("ERROR:Failed to create an incoming call\n");
+      return OO_FAILED;
+   }
+
+   call->pH225Channel = (OOH323Channel*) 
+      memAllocZ (call->pctxt, sizeof(OOH323Channel));
+
+   call->pH225Channel->sock = h225Channel;
+
+   /* If multihomed, get ip from socket */
+   if(!strcmp(call->localIP, "0.0.0.0"))
+   {
+      OOTRACEDBGA3("Determining IP address for incoming call in multihomed "
+                   "mode (%s, %s)\n", call->callType, call->callToken);
+
+      ret = ooSocketGetIpAndPort(h225Channel, call->localIP, 20, 
+                                       &call->pH225Channel->port);
+      if(ret != ASN_OK)
+      {
+         OOTRACEERR3("Error:Failed to retrieve local ip and port from "
+                     "socket for multihomed mode.(%s, %s)\n", 
+                      call->callType, call->callToken);
+         if(call->callState < OO_CALL_CLEAR)
+         {  /* transport failure */
+            call->callState = OO_CALL_CLEAR;
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+         }
+         return OO_FAILED;
+      }
+      OOTRACEDBGA4("Using Local IP address %s for incoming call in multihomed "
+                   "mode. (%s, %s)\n", call->localIP, call->callType, 
+                    call->callToken);
+   }
+
+   return OO_OK;
+}
+
+int ooAcceptH245Connection(OOH323CallData *call)
+{
+   int ret;
+   OOSOCKET h245Channel=0;
+   ret = ooSocketAccept (*(call->h245listener), &h245Channel, 
+                         NULL, NULL);
+   if(ret != ASN_OK)
+   {
+      OOTRACEERR1("Error:Accepting h245 connection\n");
+      return OO_FAILED;
+   }
+
+   if (0 == call->pH245Channel) {
+      call->pH245Channel = 
+         (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel));
+   }
+   call->pH245Channel->sock = h245Channel; 
+   call->h245SessionState = OO_H245SESSION_ACTIVE;
+
+
+   OOTRACEINFO3("H.245 connection established (%s, %s)\n", 
+                call->callType, call->callToken);
+
+
+   /* Start terminal capability exchange and master slave determination */
+   ret = ooSendTermCapMsg(call);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n",
+                   call->callType, call->callToken);
+      return ret;
+   }
+   ret = ooSendMasterSlaveDetermination(call);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR:Sending Master-slave determination message "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return ret;
+   }   
+   return OO_OK;
+}
+
+
+int ooSetFDSETs(fd_set *pReadfds, fd_set *pWritefds, int *nfds)
+{
+   OOH323CallData *call=NULL;
+
+   if(gH323ep.gkClient && gH323ep.gkClient->rasSocket != 0)
+   {
+      FD_SET(gH323ep.gkClient->rasSocket, pReadfds );
+      if ( *nfds < (int)gH323ep.gkClient->rasSocket)
+         *nfds = (int)gH323ep.gkClient->rasSocket;
+   }
+   if(gH323ep.listener)
+   {
+      FD_SET(*(gH323ep.listener), pReadfds);
+      if(*nfds < (int)*(gH323ep.listener))
+         *nfds = *((int*)gH323ep.listener);
+   }
+
+   if(gH323ep.cmdSock)
+   {
+      FD_SET(gH323ep.cmdSock, pReadfds);
+      if(*nfds < (int)gH323ep.cmdSock)
+         *nfds = (int)gH323ep.cmdSock;
+   }
+
+
+      
+   if(gH323ep.callList)
+   {
+      call = gH323ep.callList;
+      while(call)
+      {
+         if (0 != call->pH225Channel && 0 != call->pH225Channel->sock)
+         {
+            FD_SET (call->pH225Channel->sock, pReadfds);
+            if (call->pH225Channel->outQueue.count > 0 ||
+               (OO_TESTFLAG (call->flags, OO_M_TUNNELING) && 
+                0 != call->pH245Channel && 
+                call->pH245Channel->outQueue.count>0))
+               FD_SET (call->pH225Channel->sock, pWritefds);
+            if(*nfds < (int)call->pH225Channel->sock)
+               *nfds = call->pH225Channel->sock;
+         }
+           
+         if (0 != call->pH245Channel &&  call->pH245Channel->sock != 0)
+         {
+            FD_SET(call->pH245Channel->sock, pReadfds);
+            if (call->pH245Channel->outQueue.count>0)
+               FD_SET(call->pH245Channel->sock, pWritefds);
+            if(*nfds < (int)call->pH245Channel->sock)
+               *nfds = call->pH245Channel->sock;
+         }
+         else if(call->h245listener)
+         {
+            OOTRACEINFO3("H.245 Listerner socket being monitored "
+                         "(%s, %s)\n", call->callType, call->callToken);
+             FD_SET(*(call->h245listener), pReadfds);
+             if(*nfds < (int)*(call->h245listener))
+               *nfds = *(call->h245listener);
+          }
+          call = call->next;
+            
+      }/* while(call) */
+   }/*if(gH323ep.callList) */
+
+
+   if(*nfds != 0) *nfds = *nfds+1;
+
+   return OO_OK;
+
+}
+
+int ooProcessFDSETsAndTimers
+   (fd_set *pReadfds, fd_set *pWritefds, struct timeval *pToMin)
+{
+   OOH323CallData *call, *prev=NULL;
+   struct timeval toNext;
+
+   /* Process gatekeeper client timers */
+   if(gH323ep.gkClient)
+   {   
+      ooTimerFireExpired(&gH323ep.gkClient->ctxt, 
+                         &gH323ep.gkClient->timerList);
+      if(ooTimerNextTimeout(&gH323ep.gkClient->timerList, &toNext))
+      {
+         if(ooCompareTimeouts(pToMin, &toNext)>0)
+         {
+            pToMin->tv_sec = toNext.tv_sec;
+            pToMin->tv_usec = toNext.tv_usec;
+         }
+      }
+      if(gH323ep.gkClient->state == GkClientFailed ||
+         gH323ep.gkClient->state == GkClientGkErr)
+      {
+         if(ooGkClientHandleClientOrGkFailure(gH323ep.gkClient)!=OO_OK)
+         {
+            //ooStopMonitorCalls(); //Function calling ooProcessFDSETsAndTimers is responsible for this.
+            return OO_FAILED;
+         }
+      }
+   }
+
+   if(gH323ep.cmdSock) {
+      if(FD_ISSET(gH323ep.cmdSock, pReadfds)) {
+         if(ooReadAndProcessStackCommand() != OO_OK) {
+			 /* ooReadAndProcessStackCommand prints an error message */
+			 return OO_FAILED;
+		 }
+      }
+   }
+
+   /* Manage ready descriptors after select */
+
+   if(0 != gH323ep.gkClient && 0 != gH323ep.gkClient->rasSocket)
+   {
+      if(FD_ISSET( gH323ep.gkClient->rasSocket, pReadfds) )
+      {
+         ooGkClientReceive(gH323ep.gkClient);
+         if(gH323ep.gkClient->state == GkClientFailed ||
+            gH323ep.gkClient->state == GkClientGkErr) {
+            ooGkClientHandleClientOrGkFailure(gH323ep.gkClient);
+         }
+      }
+   }
+
+   if(gH323ep.listener)
+   {
+      if(FD_ISSET(*(gH323ep.listener), pReadfds))
+      {
+         OOTRACEDBGA1("New connection at H225 receiver\n");
+         ooAcceptH225Connection();
+      }      
+   }
+      
+ 
+   if(gH323ep.callList)
+   {
+      call = gH323ep.callList;
+      while(call)
+      {
+         ooTimerFireExpired(call->pctxt, &call->timerList);
+         if (0 != call->pH225Channel && 0 != call->pH225Channel->sock)
+         {
+            if(FD_ISSET(call->pH225Channel->sock, pReadfds))
+            {
+               if(ooH2250Receive(call) != OO_OK)
+               {
+                  OOTRACEERR3("ERROR:Failed ooH2250Receive - Clearing call "
+                             "(%s, %s)\n", call->callType, call->callToken);
+                  if(call->callState < OO_CALL_CLEAR)
+                  {
+                     call->callEndReason = OO_REASON_INVALIDMESSAGE;
+                     call->callState = OO_CALL_CLEAR;
+                  }
+               }
+            }
+         }
+
+
+         if (0 != call->pH245Channel && 0 != call->pH245Channel->sock)
+         {
+            if(FD_ISSET(call->pH245Channel->sock, pReadfds))
+            {                           
+               ooH245Receive(call);
+            }
+         }
+            
+         if (0 != call->pH245Channel && 0 != call->pH245Channel->sock)
+         {
+            if(FD_ISSET(call->pH245Channel->sock, pWritefds))
+            {                           
+               if(call->pH245Channel->outQueue.count>0)
+                  ooSendMsg(call, OOH245MSG);
+            }
+         }
+         else if(call->h245listener)
+         {
+            if(FD_ISSET(*(call->h245listener), pReadfds))
+            {
+               OOTRACEDBGC3("Incoming H.245 connection (%s, %s)\n",
+                            call->callType, call->callToken);
+               ooAcceptH245Connection(call);
+            }                           
+         }
+
+         if (0 != call->pH225Channel && 0 != call->pH225Channel->sock)
+         {
+            if(FD_ISSET(call->pH225Channel->sock, pWritefds))
+            {
+               if(call->pH225Channel->outQueue.count>0)
+               {
+                  OOTRACEDBGC3("Sending H225 message (%s, %s)\n", 
+                              call->callType, call->callToken);
+                  ooSendMsg(call, OOQ931MSG);
+               }
+               if(call->pH245Channel && 
+                  call->pH245Channel->outQueue.count>0 && 
+                  OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+               {
+                  OOTRACEDBGC3("H245 message needs to be tunneled. "
+                               "(%s, %s)\n", call->callType, 
+                               call->callToken);
+                  ooSendMsg(call, OOH245MSG);
+               }
+            }                                
+         }
+
+         if(ooTimerNextTimeout(&call->timerList, &toNext))
+         {
+            if(ooCompareTimeouts(pToMin, &toNext) > 0)
+            {
+               pToMin->tv_sec = toNext.tv_sec;
+               pToMin->tv_usec = toNext.tv_usec;
+            }
+         }
+         prev = call;
+         call = call->next;
+         if(prev->callState >= OO_CALL_CLEAR)
+            ooEndCall(prev);
+      }/* while(call) */
+   }/* if(gH323ep.callList) */
+
+   return OO_OK;
+
+}
+   
+int ooMonitorChannels()
+{
+   int ret=0, nfds=0;
+   struct timeval toMin, toNext;
+   fd_set readfds, writefds;
+
+   gMonitor = TRUE;
+
+   toMin.tv_sec = 3;
+   toMin.tv_usec = 0;
+   ooH323EpPrintConfig();
+   
+   if(gH323ep.gkClient) {
+      ooGkClientPrintConfig(gH323ep.gkClient);
+      if(OO_OK != ooGkClientStart(gH323ep.gkClient))
+      {
+         OOTRACEERR1("Error:Failed to start Gatekeeper client\n");
+         ooGkClientDestroy();
+      }
+   }
+   
+   while(1)
+   {
+      FD_ZERO(&readfds);
+      FD_ZERO(&writefds);
+      nfds = 0;
+      ooSetFDSETs(&readfds, &writefds, &nfds);
+
+      if(!gMonitor) {
+         OOTRACEINFO1("Ending Monitor thread\n");
+         break;
+      }
+
+      
+      if(nfds == 0)
+#ifdef _WIN32
+         Sleep(10);
+#else
+      {
+         toMin.tv_sec = 0;
+         toMin.tv_usec = 10000;
+         ooSocketSelect(1, 0, 0, 0, &toMin);
+      }
+#endif
+      else
+         ret = ooSocketSelect(nfds, &readfds, &writefds, 
+                           NULL, &toMin);
+      
+      if(ret == -1)
+      {
+         
+         OOTRACEERR1("Error in select ...exiting\n");
+         exit(-1);
+      }
+
+      toMin.tv_sec = 0;
+      toMin.tv_usec = 100000; /* 100ms*/
+      /*This is for test application. Not part of actual stack */
+  
+      ooTimerFireExpired(&gH323ep.ctxt, &g_TimerList);
+      if(ooTimerNextTimeout(&g_TimerList, &toNext))
+      {
+         if(ooCompareTimeouts(&toMin, &toNext)>0)
+         {
+            toMin.tv_sec = toNext.tv_sec;
+            toMin.tv_usec = toNext.tv_usec;
+         }
+      }
+
+      if(ooProcessFDSETsAndTimers(&readfds, &writefds, &toMin) != OO_OK)
+      {
+         ooStopMonitorCalls();
+         continue;
+      }
+
+   }/* while(1)*/
+   return OO_OK;
+}
+
+int ooH2250Receive(OOH323CallData *call)
+{
+   int  recvLen=0, total=0, ret=0;
+   ASN1OCTET message[MAXMSGLEN], message1[MAXMSGLEN];
+   int len;
+   Q931Message *pmsg;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   struct timeval timeout;
+   fd_set readfds;
+
+   
+   pmsg = (Q931Message*)memAlloc(pctxt, sizeof(Q931Message));
+   if(!pmsg)
+   {
+      OOTRACEERR3("ERROR:Failed to allocate memory for incoming H.2250 message"
+                  " (%s, %s)\n", call->callType, call->callToken);
+      memReset(&gH323ep.msgctxt);
+      return OO_FAILED;
+   }
+   memset(pmsg, 0, sizeof(Q931Message));
+   /* First read just TPKT header which is four bytes */
+   recvLen = ooSocketRecv (call->pH225Channel->sock, message, 4);
+   if(recvLen <= 0)
+   {
+      if(recvLen == 0)
+         OOTRACEWARN3("Warn:RemoteEndpoint closed connection (%s, %s)\n",
+                      call->callType, call->callToken);
+      else
+         OOTRACEERR3("Error:Transport failure while reading Q931 "
+                     "message (%s, %s)\n", call->callType, call->callToken);
+
+      ooCloseH225Connection(call);
+      if(call->callState < OO_CALL_CLEARED)
+      {
+         if(call->callState < OO_CALL_CLEAR)
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+         call->callState = OO_CALL_CLEARED;
+         
+      }
+      ooFreeQ931Message(pmsg);
+      return OO_OK;
+   }
+   OOTRACEDBGC3("Receiving H.2250 message (%s, %s)\n",
+                call->callType, call->callToken);   
+   /* Since we are working with TCP, need to determine the
+      message boundary. Has to be done at channel level, as channels
+      know the message formats and can determine boundaries
+   */
+   if(recvLen != 4)
+   {
+      OOTRACEERR4("Error: Reading TPKT header for H225 message "
+                  "recvLen= %d (%s, %s)\n", recvLen, call->callType, 
+                  call->callToken);
+      ooFreeQ931Message(pmsg);
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callEndReason = OO_REASON_INVALIDMESSAGE;
+         call->callState = OO_CALL_CLEAR;
+      }
+      return OO_FAILED;
+   }
+
+   
+   len = message[2];
+   len = len<<8;
+   len = len | message[3];
+   /* Remaining message length is length - tpkt length */
+   len = len - 4;
+
+   /* Now read actual Q931 message body. We should make sure that we
+      receive complete message as indicated by len. If we don't then there 
+      is something wrong. The loop below receives message, then checks whether
+      complete message is received. If not received, then uses select to peek
+      for remaining bytes of the message. If message is not received in 3
+      seconds, then we have a problem. Report an error and exit.
+   */
+   while(total < len)
+   {
+      recvLen = ooSocketRecv (call->pH225Channel->sock, message1, len-total);
+      memcpy(message+total, message1, recvLen);
+      total = total + recvLen;
+
+      if(total == len) break; /* Complete message is received */
+      
+      FD_ZERO(&readfds);
+      FD_SET(call->pH225Channel->sock, &readfds);
+      timeout.tv_sec = 3;
+      timeout.tv_usec = 0;
+      ret = ooSocketSelect(call->pH225Channel->sock+1, &readfds, NULL, 
+                           NULL, &timeout);
+      if(ret == -1)
+      {
+         OOTRACEERR3("Error in select while receiving H.2250 message - "
+                     "clearing call (%s, %s)\n", call->callType, 
+                     call->callToken);
+         ooFreeQ931Message(pmsg);
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+      /* If remaining part of the message is not received in 3 seconds 
+         exit */
+      if(!FD_ISSET(call->pH225Channel->sock, &readfds))
+      {
+         OOTRACEERR3("Error: Incomplete H.2250 message received - clearing "
+                     "call (%s, %s)\n", call->callType, call->callToken);
+         ooFreeQ931Message(pmsg);
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_INVALIDMESSAGE; 
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+   }
+
+   OOTRACEDBGC3("Received Q.931 message: (%s, %s)\n", 
+                call->callType, call->callToken);
+
+   initializePrintHandler(&printHandler, "Received H.2250 Message");
+   setEventHandler (pctxt, &printHandler);
+   ret = ooQ931Decode (call, pmsg, len, message);
+   if(ret != OO_OK) {
+      OOTRACEERR3("Error:Failed to decode received H.2250 message. (%s, %s)\n",
+                   call->callType, call->callToken);
+   }
+   OOTRACEDBGC3("Decoded Q931 message (%s, %s)\n", call->callType, 
+                call->callToken);
+   finishPrint();
+   removeEventHandler(pctxt);
+   if(ret == OO_OK) {
+      ooHandleH2250Message(call, pmsg);
+   }
+   return ret;
+}
+
+
+
+int ooH245Receive(OOH323CallData *call)
+{
+   int  recvLen, ret, len, total=0;
+   ASN1OCTET message[MAXMSGLEN], message1[MAXMSGLEN];
+   ASN1BOOL aligned = TRUE;
+   H245Message *pmsg;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   struct timeval timeout;
+   fd_set readfds;
+   
+   pmsg = (H245Message*)memAlloc(pctxt, sizeof(H245Message));
+
+   /* First read just TPKT header which is four bytes */
+   recvLen = ooSocketRecv (call->pH245Channel->sock, message, 4);
+   /* Since we are working with TCP, need to determine the
+      message boundary. Has to be done at channel level, as channels
+      know the message formats and can determine boundaries
+   */
+   if(recvLen<=0 && call->h245SessionState != OO_H245SESSION_PAUSED)
+   {
+      if(recvLen == 0)
+         OOTRACEINFO3("Closing H.245 channels as remote end point closed H.245"
+                    " connection (%s, %s)\n", call->callType, call->callToken);
+      else
+         OOTRACEERR3("Error: Transport failure while trying to receive H245"
+                     " message (%s, %s)\n", call->callType, call->callToken);
+
+      ooCloseH245Connection(call);
+      ooFreeH245Message(call, pmsg);
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+         call->callState = OO_CALL_CLEAR;
+      }
+      return OO_FAILED;
+   }
+   if(call->h245SessionState == OO_H245SESSION_PAUSED) 
+   {
+      ooLogicalChannel *temp;
+
+      OOTRACEINFO3("Call Paused, closing logical channels"
+                    " (%s, %s)\n", call->callType, call->callToken);
+
+      temp = call->logicalChans;
+      while(temp)
+      {
+         if(temp->state == OO_LOGICALCHAN_ESTABLISHED)
+         {
+            /* Sending closelogicalchannel only for outgoing channels*/
+            if(!strcmp(temp->dir, "transmit"))
+            {
+               ooSendCloseLogicalChannel(call, temp);
+            }
+         }
+         temp = temp->next;
+      }
+      call->masterSlaveState = OO_MasterSlave_Idle;
+      call->callState = OO_CALL_PAUSED;
+      call->localTermCapState = OO_LocalTermCapExchange_Idle;
+      call->remoteTermCapState = OO_RemoteTermCapExchange_Idle;
+      call->h245SessionState = OO_H245SESSION_IDLE;
+      call->logicalChans = NULL;
+   }
+   OOTRACEDBGC1("Receiving H245 message\n");
+   if(recvLen != 4)
+   {
+      OOTRACEERR3("Error: Reading TPKT header for H245 message (%s, %s)\n",
+                  call->callType, call->callToken);
+      ooFreeH245Message(call, pmsg);
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callEndReason = OO_REASON_INVALIDMESSAGE;
+         call->callState = OO_CALL_CLEAR;
+      }
+      return OO_FAILED;
+   }
+
+   len = message[2];
+   len = len<<8;
+   len = (len | message[3]);
+   /* Remaining message length is length - tpkt length */
+   len = len - 4;
+   /* Now read actual H245 message body. We should make sure that we
+      receive complete message as indicated by len. If we don't then there 
+      is something wrong. The loop below receives message, then checks whether
+      complete message is received. If not received, then uses select to peek
+      for remaining bytes of the message. If message is not received in 3
+      seconds, then we have a problem. Report an error and exit.
+   */
+   while(total < len)
+   {
+      recvLen = ooSocketRecv (call->pH245Channel->sock, message1, len-total);
+      memcpy(message+total, message1, recvLen);
+      total = total + recvLen;
+      if(total == len) break; /* Complete message is received */
+      FD_ZERO(&readfds);
+      FD_SET(call->pH245Channel->sock, &readfds);
+      timeout.tv_sec = 3;
+      timeout.tv_usec = 0;
+      ret = ooSocketSelect(call->pH245Channel->sock+1, &readfds, NULL, 
+                           NULL, &timeout);
+      if(ret == -1)
+      {
+         OOTRACEERR3("Error in select...H245 Receive-Clearing call (%s, %s)\n",
+                     call->callType, call->callToken);
+         ooFreeH245Message(call, pmsg);
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+      /* If remaining part of the message is not received in 3 seconds 
+         exit */
+      if(!FD_ISSET(call->pH245Channel->sock, &readfds))
+      {
+         OOTRACEERR3("Error: Incomplete h245 message received (%s, %s)\n",
+                     call->callType, call->callToken);
+         ooFreeH245Message(call, pmsg);
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+   }
+
+   OOTRACEDBGC3("Complete H245 message received (%s, %s)\n", 
+                 call->callType, call->callToken);
+   setPERBuffer(pctxt, message, recvLen, aligned);
+   initializePrintHandler(&printHandler, "Received H.245 Message");
+
+   /* Set event handler */
+   setEventHandler (pctxt, &printHandler);
+
+   ret = asn1PD_H245MultimediaSystemControlMessage(pctxt, &(pmsg->h245Msg));
+   if(ret != ASN_OK)
+   {
+      OOTRACEERR3("Error decoding H245 message (%s, %s)\n", 
+                  call->callType, call->callToken);
+      ooFreeH245Message(call, pmsg);
+      return OO_FAILED;
+   }
+   finishPrint();
+   removeEventHandler(pctxt); 
+   ooHandleH245Message(call, pmsg);
+   return OO_OK;
+}
+
+/* Generic Send Message functionality. Based on type of message to be sent,
+   it calls the corresponding function to retrieve the message buffer and 
+   then transmits on the associated channel
+   Interpreting msgptr:
+      Q931 messages except facility
+                             1st octet - msgType, next 4 octets - tpkt header,
+                             followed by encoded msg
+      Q931 message facility
+                             1st octect - OOFacility, 2nd octet - tunneled msg 
+                             type(in case no tunneled msg - OOFacility), 
+                             3rd and 4th octet - associated logical channel 
+                             of the tunneled msg(0 when no channel is 
+                             associated. ex. in case of MSD, TCS), next 
+                             4 octets - tpkt header, followed by encoded 
+                             message.
+
+      H.245 messages no tunneling
+                             1st octet - msg type, next two octets - logical 
+                             channel number(0, when no channel is associated),
+                             next two octets - total length of the message
+                            (including tpkt header)
+
+      H.245 messages - tunneling.
+                             1st octet - msg type, next two octets - logical 
+                             channel number(0, when no channel is associated),
+                             next two octets - total length of the message. 
+                             Note, no tpkt header is present in this case.
+                            
+*/
+int ooSendMsg(OOH323CallData *call, int type)
+{
+
+   int len=0, ret=0, msgType=0, tunneledMsgType=0, logicalChannelNo = 0;
+   DListNode * p_msgNode=NULL;
+   ASN1OCTET *msgptr, *msgToSend=NULL;
+   
+
+
+   if(call->callState == OO_CALL_CLEARED)
+   {
+      OOTRACEDBGA3("Warning:Call marked for cleanup. Can not send message."
+                   "(%s, %s)\n", call->callType, call->callToken);
+      return OO_OK;
+   }
+
+   if(type == OOQ931MSG)
+   {
+      if(call->pH225Channel->outQueue.count == 0)
+      {
+         OOTRACEWARN3("WARN:No H.2250 message to send. (%s, %s)\n", 
+                      call->callType, call->callToken);
+         return OO_FAILED;
+      }
+
+      OOTRACEDBGA3("Sending Q931 message (%s, %s)\n", call->callType, 
+                                                      call->callToken);
+      p_msgNode = call->pH225Channel->outQueue.head;
+      msgptr = (ASN1OCTET*) p_msgNode->data;
+      msgType = msgptr[0];
+
+      if(msgType == OOFacility)
+      {
+         tunneledMsgType = msgptr[1];
+         logicalChannelNo = msgptr[2];
+         logicalChannelNo = logicalChannelNo << 8;
+         logicalChannelNo = (logicalChannelNo | msgptr[3]);
+         len = msgptr[6];
+         len = len<<8;
+         len = (len | msgptr[7]);
+         msgToSend = msgptr+4;
+      }
+      else {
+         len = msgptr[3];
+         len = len<<8;
+         len = (len | msgptr[4]);
+         msgToSend = msgptr+1;
+      }
+
+      /* Remove the message from rtdlist pH225Channel->outQueue */
+      dListRemove(&(call->pH225Channel->outQueue), p_msgNode);
+      if(p_msgNode)
+         memFreePtr(call->pctxt, p_msgNode);
+      
+      /*TODO: This is not required ideally. We will see for some time and if
+         we don't face any problems we will delete this code */
+#if 0 
+      /* Check whether connection with remote is alright */
+      if(!ooChannelsIsConnectionOK(call, call->pH225Channel->sock))
+      {
+         OOTRACEERR3("Error:Transport failure for signalling channel. "
+                     "Abandoning message send and marking call for cleanup.(%s"
+                     "'%s)\n", call->callType, call->callToken);
+         if(call->callState < OO_CALL_CLEAR)
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+         call->callState = OO_CALL_CLEARED;
+         return OO_OK;
+      }
+#endif     
+      /* Send message out via TCP */      
+      ret = ooSocketSend(call->pH225Channel->sock, msgToSend, len);
+      if(ret == ASN_OK)
+      {
+         memFreePtr (call->pctxt, msgptr);
+         OOTRACEDBGC3("H2250/Q931 Message sent successfully (%s, %s)\n", 
+                      call->callType, call->callToken);
+         ooOnSendMsg(call, msgType, tunneledMsgType, logicalChannelNo);
+         return OO_OK;
+      }
+      else{
+         OOTRACEERR3("H2250Q931 Message send failed (%s, %s)\n", 
+                     call->callType, call->callToken);
+         memFreePtr (call->pctxt, msgptr);
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+   }/* end of type==OOQ931MSG */
+   if(type == OOH245MSG)
+   {
+      if(call->pH245Channel->outQueue.count == 0)
+      {
+         OOTRACEWARN3("WARN:No H.245 message to send. (%s, %s)\n", 
+                                 call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      OOTRACEDBGA3("Sending H245 message (%s, %s)\n", call->callType, 
+                                                      call->callToken);
+      p_msgNode = call->pH245Channel->outQueue.head;
+      msgptr = (ASN1OCTET*) p_msgNode->data;
+      msgType = msgptr[0];
+
+      logicalChannelNo = msgptr[1];
+      logicalChannelNo = logicalChannelNo << 8;
+      logicalChannelNo = (logicalChannelNo | msgptr[2]);
+
+      len = msgptr[3];
+      len = len<<8;
+      len = (len | msgptr[4]);
+      /* Remove the message from queue */
+      dListRemove(&(call->pH245Channel->outQueue), p_msgNode);
+      if(p_msgNode)
+         memFreePtr(call->pctxt, p_msgNode);
+
+      /* Send message out */
+      if (0 == call->pH245Channel && !OO_TESTFLAG(call->flags, OO_M_TUNNELING))
+      {
+         OOTRACEWARN3("Neither H.245 channel nor tunneling active "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         memFreePtr (call->pctxt, msgptr);
+         /*ooCloseH245Session(call);*/
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_OK;
+      }
+      
+      if (0 != call->pH245Channel && 0 != call->pH245Channel->sock)
+      {
+         OOTRACEDBGC4("Sending %s H245 message over H.245 channel. "
+                      "(%s, %s)\n", ooGetMsgTypeText(msgType), 
+                      call->callType, call->callToken);
+
+         ret = ooSocketSend(call->pH245Channel->sock, msgptr+5, len);
+         if(ret == ASN_OK)
+         {
+            memFreePtr (call->pctxt, msgptr);
+            OOTRACEDBGA3("H245 Message sent successfully (%s, %s)\n", 
+                          call->callType, call->callToken);
+            ooOnSendMsg(call, msgType, tunneledMsgType, logicalChannelNo);
+            return OO_OK;
+         }
+         else{
+            memFreePtr (call->pctxt, msgptr);
+            OOTRACEERR3("ERROR:H245 Message send failed (%s, %s)\n", 
+                        call->callType, call->callToken);
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+               call->callState = OO_CALL_CLEAR;
+            }
+            return OO_FAILED;
+         }
+      }
+      else if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) {
+         OOTRACEDBGC4("Sending %s H245 message as a tunneled message."
+                      "(%s, %s)\n", ooGetMsgTypeText(msgType), 
+                      call->callType, call->callToken);
+
+         ret = ooSendAsTunneledMessage
+                  (call, msgptr+5,len,msgType, logicalChannelNo);
+
+         if(ret != OO_OK)
+         {
+            memFreePtr (call->pctxt, msgptr);
+            OOTRACEERR3("ERROR:Failed to tunnel H.245 message (%s, %s)\n",
+                         call->callType, call->callToken);
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_INVALIDMESSAGE;
+               call->callState = OO_CALL_CLEAR;
+            }
+            return OO_FAILED;
+         }
+         memFreePtr (call->pctxt, msgptr);
+         return OO_OK;
+      }
+   }
+   /* Need to add support for other messages such as T38 etc */
+   OOTRACEWARN3("ERROR:Unknown message type - message not Sent (%s, %s)\n",
+                call->callType, call->callToken);
+   return OO_FAILED;
+}       
+
+int ooCloseH245Connection(OOH323CallData *call)
+{
+   OOTRACEINFO3("Closing H.245 connection (%s, %s)\n", call->callType, 
+                call->callToken);
+
+   if (0 != call->pH245Channel)
+   {
+      if(0 != call->pH245Channel->sock)
+         ooSocketClose (call->pH245Channel->sock);
+      if (call->pH245Channel->outQueue.count > 0)
+         dListFreeAll(call->pctxt, &(call->pH245Channel->outQueue));
+      memFreePtr (call->pctxt, call->pH245Channel);
+      call->pH245Channel = NULL;
+      OOTRACEDBGC3("Closed H245 connection. (%s, %s)\n", call->callType, 
+                                                       call->callToken);
+   }
+   call->h245SessionState = OO_H245SESSION_CLOSED;
+
+   return OO_OK;
+}
+
+int ooCloseH245Listener(OOH323CallData *call)
+{
+   OOTRACEINFO3("Closing H.245 Listener (%s, %s)\n", call->callType, 
+                call->callToken);
+   if(call->h245listener)
+   {
+      ooSocketClose(*(call->h245listener));
+      memFreePtr(call->pctxt, call->h245listener);
+      call->h245listener = NULL;
+   }
+   return OO_OK;
+}
+
+int ooOnSendMsg
+   (OOH323CallData *call, int msgType, int tunneledMsgType, int associatedChan)
+{
+   ooTimerCallback *cbData=NULL;
+   switch(msgType)
+   {
+   case OOSetup:
+      OOTRACEINFO3("Sent Message - Setup (%s, %s)\n", call->callType, 
+                    call->callToken);
+      /* Start call establishment timer */
+      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                     sizeof(ooTimerCallback));
+      if(!cbData)
+      {
+         OOTRACEERR3("Error:Unable to allocate memory for timer callback."
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      cbData->call = call;
+      cbData->timerType = OO_CALLESTB_TIMER;
+      if(!ooTimerCreate(call->pctxt, &call->timerList, &ooCallEstbTimerExpired,
+                        gH323ep.callEstablishmentTimeout, cbData, FALSE))
+      {
+         OOTRACEERR3("Error:Unable to create call establishment timer. "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         memFreePtr(call->pctxt, cbData);
+         return OO_FAILED;
+      }
+
+      if(gH323ep.h323Callbacks.onOutgoingCall)
+         gH323ep.h323Callbacks.onOutgoingCall(call);
+      break;
+   case OOCallProceeding:
+      OOTRACEINFO3("Sent Message - CallProceeding (%s, %s)\n", call->callType,
+                    call->callToken);
+      break;
+   case OOAlert:
+      OOTRACEINFO3("Sent Message - Alerting (%s, %s) \n", call->callType,
+                    call->callToken);
+      if(gH323ep.h323Callbacks.onAlerting && call->callState < OO_CALL_CLEAR)
+         gH323ep.h323Callbacks.onAlerting(call);
+      break;
+   case OOConnect:
+      OOTRACEINFO3("Sent Message - Connect (%s, %s)\n", call->callType,
+                    call->callToken);
+      if(gH323ep.h323Callbacks.onCallEstablished)
+         gH323ep.h323Callbacks.onCallEstablished(call);
+      break;
+   case OOReleaseComplete:
+      OOTRACEINFO3("Sent Message - ReleaseComplete (%s, %s)\n", call->callType,
+                    call->callToken);
+
+      if(call->callState == OO_CALL_CLEAR_RELEASERECVD)
+         call->callState = OO_CALL_CLEARED;
+      else{
+         call->callState = OO_CALL_CLEAR_RELEASESENT;
+         if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK) && 
+            gH323ep.gkClient->state == GkClientRegistered){
+            OOTRACEDBGA3("Sending DRQ after sending ReleaseComplete."
+                         "(%s, %s)\n",   call->callType, call->callToken);
+            ooGkClientSendDisengageRequest(gH323ep.gkClient, call);
+         }
+      }
+
+      if(call->callState == OO_CALL_CLEAR_RELEASESENT && 
+         call->h245SessionState == OO_H245SESSION_IDLE)
+      {
+         cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                  sizeof(ooTimerCallback));
+         if(!cbData)
+         {
+            OOTRACEERR3("Error:Unable to allocate memory for timer callback "
+                        "data.(%s, %s)\n", call->callType, call->callToken);
+            return OO_FAILED;
+         }
+         cbData->call = call;
+         cbData->timerType = OO_SESSION_TIMER;
+         cbData->channelNumber = 0;
+         if(!ooTimerCreate(call->pctxt, &call->timerList, 
+             &ooSessionTimerExpired, gH323ep.sessionTimeout, cbData, FALSE))
+         {
+            OOTRACEERR3("Error:Unable to create EndSession timer- "
+                        "ReleaseComplete.(%s, %s)\n", call->callType, 
+                        call->callToken);
+            memFreePtr(call->pctxt, cbData);
+            return OO_FAILED;
+         }
+      }
+
+      if(call->h245SessionState == OO_H245SESSION_CLOSED)
+      {
+         call->callState = OO_CALL_CLEARED;
+      }
+      break;
+
+   case OOFacility:
+      if(tunneledMsgType == OOFacility)
+      {
+         OOTRACEINFO3("Sent Message - Facility. (%s, %s)\n", 
+                      call->callType, call->callToken);
+      }
+      else{
+         OOTRACEINFO4("Sent Message - Facility(%s) (%s, %s)\n", 
+                      ooGetMsgTypeText(tunneledMsgType), 
+                      call->callType, call->callToken);
+
+         ooOnSendMsg(call, tunneledMsgType, 0, associatedChan);
+      }
+      break;
+
+   case OOMasterSlaveDetermination:
+     if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+        OOTRACEINFO3("Tunneled Message - MasterSlaveDetermination (%s, %s)\n", 
+                      call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - MasterSlaveDetermination (%s, %s)\n", 
+                       call->callType, call->callToken);
+       /* Start MSD timer */
+      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                     sizeof(ooTimerCallback));
+      if(!cbData)
+      {
+         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      cbData->call = call;
+      cbData->timerType = OO_MSD_TIMER;
+      if(!ooTimerCreate(call->pctxt, &call->timerList, &ooMSDTimerExpired,
+                        gH323ep.msdTimeout, cbData, FALSE))
+      {
+         OOTRACEERR3("Error:Unable to create MSD timer. "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         memFreePtr(call->pctxt, cbData);
+         return OO_FAILED;
+      }
+
+      break;
+   case OOMasterSlaveAck:
+     if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationAck (%s, %s)"
+                      "\n",  call->callType, call->callToken);
+     else
+        OOTRACEINFO3("Sent Message - MasterSlaveDeterminationAck (%s, %s)\n", 
+                    call->callType, call->callToken);
+      break;
+   case OOMasterSlaveReject:
+     if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+        OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationReject "
+                     "(%s, %s)\n", call->callType, call->callToken);
+     else
+        OOTRACEINFO3("Sent Message - MasterSlaveDeterminationReject(%s, %s)\n",
+                    call->callType, call->callToken);
+      break;
+   case OOMasterSlaveRelease:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationRelease "
+                      "(%s, %s)\n", call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - MasterSlaveDeterminationRelease "
+                      "(%s, %s)\n", call->callType, call->callToken);
+      break;
+   case OOTerminalCapabilitySet:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) {
+         /* If session isn't marked active yet, do it. possible in case of 
+            tunneling */
+         if(call->h245SessionState == OO_H245SESSION_IDLE ||
+            call->h245SessionState == OO_H245SESSION_PAUSED) {
+            call->h245SessionState = OO_H245SESSION_ACTIVE;
+         }
+         OOTRACEINFO3("Tunneled Message - TerminalCapabilitySet (%s, %s)\n", 
+                       call->callType, call->callToken);
+      }
+      else {
+         OOTRACEINFO3("Sent Message - TerminalCapabilitySet (%s, %s)\n", 
+                       call->callType, call->callToken);
+      }
+      /* Start TCS timer */
+      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                     sizeof(ooTimerCallback));
+      if(!cbData)
+      {
+         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      cbData->call = call;
+      cbData->timerType = OO_TCS_TIMER;
+      if(!ooTimerCreate(call->pctxt, &call->timerList, &ooTCSTimerExpired,
+                        gH323ep.tcsTimeout, cbData, FALSE))
+      {
+         OOTRACEERR3("Error:Unable to create TCS timer. "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         memFreePtr(call->pctxt, cbData);
+         return OO_FAILED;
+      }
+      break;
+
+
+   case OOTerminalCapabilitySetAck:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - TerminalCapabilitySetAck (%s, %s)\n",
+                       call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - TerminalCapabilitySetAck (%s, %s)\n", 
+                       call->callType, call->callToken);
+      break;
+   case OOTerminalCapabilitySetReject:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - TerminalCapabilitySetReject "
+                      "(%s, %s)\n",  call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - TerminalCapabilitySetReject (%s, %s)\n", 
+                       call->callType, call->callToken);
+      break;
+   case OOOpenLogicalChannel:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO4("Tunneled Message - OpenLogicalChannel(%d). (%s, %s)\n", 
+                       associatedChan, call->callType, call->callToken);
+      else
+         OOTRACEINFO4("Sent Message - OpenLogicalChannel(%d). (%s, %s)\n", 
+                       associatedChan, call->callType, call->callToken);
+      /* Start LogicalChannel timer */
+      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                     sizeof(ooTimerCallback));
+      if(!cbData)
+      {
+         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      cbData->call = call;
+      cbData->timerType = OO_OLC_TIMER;
+      cbData->channelNumber = associatedChan;
+      if(!ooTimerCreate(call->pctxt, &call->timerList, 
+          &ooOpenLogicalChannelTimerExpired, gH323ep.logicalChannelTimeout, 
+          cbData, FALSE))
+      {
+         OOTRACEERR3("Error:Unable to create OpenLogicalChannel timer. "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         memFreePtr(call->pctxt, cbData);
+         return OO_FAILED;
+      }
+      
+      break;
+   case OOOpenLogicalChannelAck:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO4("Tunneled Message - OpenLogicalChannelAck(%d) (%s,%s)\n",
+                       associatedChan, call->callType, call->callToken);
+      else
+         OOTRACEINFO4("Sent Message - OpenLogicalChannelAck(%d) (%s, %s)\n", 
+                       associatedChan, call->callType, call->callToken);
+      break;
+   case OOOpenLogicalChannelReject:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO4("Tunneled Message - OpenLogicalChannelReject(%d)"
+                      "(%s, %s)\n", associatedChan, call->callType, 
+                      call->callToken);
+      else
+         OOTRACEINFO4("Sent Message - OpenLogicalChannelReject(%d) (%s, %s)\n",
+                       associatedChan, call->callType, call->callToken);
+      break;
+   case OOEndSessionCommand:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - EndSessionCommand(%s, %s)\n", 
+                                             call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - EndSessionCommand (%s, %s)\n", 
+                                           call->callType, call->callToken);
+      if((call->h245SessionState == OO_H245SESSION_ACTIVE))
+      { 
+         /* Start EndSession timer */
+         call->h245SessionState = OO_H245SESSION_ENDSENT;
+         cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                  sizeof(ooTimerCallback));
+         if(!cbData)
+         {
+            OOTRACEERR3("Error:Unable to allocate memory for timer callback "
+                        "data.(%s, %s)\n", call->callType, call->callToken);
+            return OO_FAILED;
+         }
+         cbData->call = call;
+         cbData->timerType = OO_SESSION_TIMER;
+         cbData->channelNumber = 0;
+         if(!ooTimerCreate(call->pctxt, &call->timerList, 
+             &ooSessionTimerExpired, gH323ep.sessionTimeout, cbData, FALSE))
+         {
+            OOTRACEERR3("Error:Unable to create EndSession timer. "
+                        "(%s, %s)\n", call->callType, call->callToken);
+            memFreePtr(call->pctxt, cbData);
+            return OO_FAILED;
+         }
+      }
+      else{
+         ooCloseH245Connection(call);
+      }
+      break;
+   case OOCloseLogicalChannel:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - CloseLogicalChannel (%s, %s)\n", 
+                       call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - CloseLogicalChannel (%s, %s)\n", 
+                       call->callType, call->callToken);
+      /* Start LogicalChannel timer */
+      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                     sizeof(ooTimerCallback));
+      if(!cbData)
+      {
+         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      cbData->call = call;
+      cbData->timerType = OO_CLC_TIMER;
+      cbData->channelNumber = associatedChan;
+      if(!ooTimerCreate(call->pctxt, &call->timerList, 
+          &ooCloseLogicalChannelTimerExpired, gH323ep.logicalChannelTimeout, 
+          cbData, FALSE))
+      {
+         OOTRACEERR3("Error:Unable to create CloseLogicalChannel timer. "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         memFreePtr(call->pctxt, cbData);
+         return OO_FAILED;
+      }
+      
+      break;
+   case OOCloseLogicalChannelAck:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - CloseLogicalChannelAck (%s, %s)\n", 
+                       call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - CloseLogicalChannelAck (%s, %s)\n", 
+                       call->callType, call->callToken);
+      break;
+   case OORequestChannelClose:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - RequestChannelClose (%s, %s)\n", 
+                       call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - RequestChannelClose (%s, %s)\n", 
+                       call->callType, call->callToken);
+      /* Start RequestChannelClose timer */
+      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
+                                                     sizeof(ooTimerCallback));
+      if(!cbData)
+      {
+         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      cbData->call = call;
+      cbData->timerType = OO_RCC_TIMER;
+      cbData->channelNumber = associatedChan;
+      if(!ooTimerCreate(call->pctxt, &call->timerList, 
+          &ooRequestChannelCloseTimerExpired, gH323ep.logicalChannelTimeout, 
+          cbData, FALSE))
+      {
+         OOTRACEERR3("Error:Unable to create RequestChannelClose timer. "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         memFreePtr(call->pctxt, cbData);
+         return OO_FAILED;
+      }
+      break;
+   case OORequestChannelCloseAck:
+      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         OOTRACEINFO3("Tunneled Message - RequestChannelCloseAck (%s, %s)\n", 
+                       call->callType, call->callToken);
+      else
+         OOTRACEINFO3("Sent Message - RequestChannelCloseAck (%s, %s)\n", 
+                       call->callType, call->callToken);
+      break;
+   
+   default:
+     ;
+   }
+   return OO_OK;
+}
+
+
+int ooStopMonitorCalls()
+{
+   OOH323CallData * call;
+   if(gMonitor)
+   {
+      OOTRACEINFO1("Doing ooStopMonitorCalls\n");
+      if(gH323ep.cmdSock)
+      {
+         ooCloseCmdConnection();
+      }
+
+      if(gH323ep.callList)
+      {
+         OOTRACEWARN1("Warn:Abruptly ending calls as stack going down\n");
+         call = gH323ep.callList;
+         while(call)
+         {
+            OOTRACEWARN3("Clearing call (%s, %s)\n", call->callType, 
+                          call->callToken);
+            call->callEndReason = OO_REASON_LOCAL_CLEARED;
+            ooCleanCall(call);
+            call = NULL;
+            call = gH323ep.callList;
+         }
+         gH323ep.callList = NULL;
+      }
+      OOTRACEINFO1("Stopping listener for incoming calls\n");   
+      if(gH323ep.listener)
+      {
+         ooSocketClose(*(gH323ep.listener));
+         memFreePtr(&gH323ep.ctxt, gH323ep.listener);
+         gH323ep.listener = NULL;
+      }
+
+      gMonitor = FALSE;
+      OOTRACEINFO1("Done ooStopMonitorCalls\n");
+   }
+   return OO_OK;
+}
+
+OOBOOL ooChannelsIsConnectionOK(OOH323CallData *call, OOSOCKET sock)
+{
+   struct timeval to;
+   fd_set readfds;
+   int ret = 0, nfds=0; 
+
+   to.tv_sec = 0;
+   to.tv_usec = 500;
+   FD_ZERO(&readfds);
+
+   FD_SET(sock, &readfds);
+   if(nfds < (int)sock)
+      nfds = (int)sock;
+
+   nfds++;
+
+   ret = ooSocketSelect(nfds, &readfds, NULL, NULL, &to);
+      
+   if(ret == -1)
+   {
+      OOTRACEERR3("Error in select ...broken pipe check(%s, %s)\n",
+                   call->callType, call->callToken );
+      return FALSE;
+   }
+
+   if(FD_ISSET(sock, &readfds))
+   {
+      char buf[2];      
+      if(ooSocketRecvPeek(sock, buf, 2) == 0)
+      {
+         OOTRACEWARN3("Broken pipe detected. (%s, %s)", call->callType, 
+                       call->callToken);
+         if(call->callState < OO_CALL_CLEAR)
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+         call->callState = OO_CALL_CLEARED;
+         return FALSE;
+      }
+   }
+   return TRUE;
+}  
diff --git a/addons/ooh323c/src/oochannels.h b/addons/ooh323c/src/oochannels.h
new file mode 100644
index 000000000..96befb567
--- /dev/null
+++ b/addons/ooh323c/src/oochannels.h
@@ -0,0 +1,216 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/**
+ * @file oochannels.h 
+ * This file contains functions to create and use channels. 
+ */
+#ifndef _OOCHANNELS_H_
+#define _OOCHANNELS_H_
+
+#include "H323-MESSAGES.h"
+#include "MULTIMEDIA-SYSTEM-CONTROL.h"
+#include "ootypes.h"
+#include "ooSocket.h"
+#include "ooCalls.h"
+
+#define OORECEIVER 1
+#define OOTRANSMITTER 2
+#define OODUPLEX 3
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+struct OOH323CallData;
+struct Q931Message;
+
+/** 
+ * @defgroup channels Channel Management
+ * @{
+ */
+/**
+ * This function is used to create a listener for incoming calls.
+ *
+ * @return  OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCreateH323Listener(void);
+
+/**
+ * This function is used to create a listener for incoming H.245 connections.
+ * @param call      Pointer to call for which H.245 listener has to be created
+ * 
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCreateH245Listener(struct OOH323CallData *call);
+
+/**
+ * This function is used to close an H245 listener for a call.
+ * @param call      Pointer to call for which H245 Listener has to be closed.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCloseH245Listener(struct OOH323CallData *call);
+
+/**
+ * This function is used to accept incoming H.225 connections.
+ * 
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooAcceptH225Connection(void);
+
+/**
+ * This function is used to accept an incoming H.245 connection.
+ * @param call        Pointer to a call for which H.245 connection request has
+ *                    arrived.
+ * 
+ * @return            OO_OK, on succes. OO_FAILED, on failure.
+ */
+EXTERN int ooAcceptH245Connection(struct OOH323CallData *call);
+
+/**
+ * This function is used to create an H.225 connection to the remote end point.
+ * @param call       Pointer to the call for which H.225 connection has to be 
+ *                   setup.
+ * @return           OO_OK, on succes. OO_FAILED, on failure. 
+ */
+EXTERN int ooCreateH225Connection(struct OOH323CallData *call);
+
+/**
+ * This function is used to setup an H.245 connection with the remote endpoint
+ * for control negotiations.
+ * @param call      Pointer to call for which H.245 connection has to be setup.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCreateH245Connection(struct OOH323CallData *call);
+
+/**
+ * This function is used to close an H.225 connection
+ * @param call       Pointer to the call for which H.225 connection has to be 
+ *                   closed.
+ * 
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCloseH225Connection(struct OOH323CallData *call);
+
+/**
+ * This function is used to close an H.245 connection for a call. 
+ *
+ * @param call       Pointer to call for which H.245 connection has 
+ *                   to be closed.
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCloseH245Connection(struct OOH323CallData *call);
+
+/**
+ * This function is used to start monitoring channels for the calls. It has
+ * an infinite loop which uses select to monitor various channels.
+ * 
+ */
+EXTERN int ooMonitorChannels(void);
+
+/**
+ * This function is called to stop the monitor channels event loop.
+ * It cleans up all the active calls before stopping the monitor.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooStopMonitorCalls(void);
+
+/**
+ * This function is used to receive an H.2250 message received on a calls
+ * H.225 channel. It receives the message, decodes it and calls 
+ * 'ooHandleH2250Message' to process the message.
+ * @param call       Pointer to the call for which the message has to be 
+ *                   received.
+ * 
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH2250Receive(struct OOH323CallData *call);
+
+/**
+ * This function is used to receive an H.245 message received on a calls
+ * H.245 channel. It receives the message, decodes it and calls 
+ * 'ooHandleH245Message' to process it.
+ * @param call       Pointer to the call for which the message has to be 
+ *                   received.
+ * 
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH245Receive(struct OOH323CallData *call);
+
+/**
+ * This function is used to enqueue an H.225 message into an outgoing queue for
+ * the call.
+ * @param call      Pointer to call for which message has to be enqueued.
+ * @param msg       Pointer to the H.225 message to be sent.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooSendH225Msg(struct OOH323CallData *call, struct Q931Message *msg);
+
+/**
+ * This function is used to Send a message on the channel, when channel is 
+ * available for write.
+ * @param call       Pointer to call for which message has to be sent.
+ * @param type       Type of the message.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooSendMsg(struct OOH323CallData *call, int type);
+
+/**
+ * This function is called after a message is sent on the call's channel.
+ * It can be used to some followup action after message has been sent.
+ * @param call            Pointer to call for which message has been sent.
+ * @param msgType         Type of message
+ * @param tunneledMsgType If this message is carrying a tunneled message, then
+ *                        type of the tunneled message.
+ * @param associatedChan  The channel number associated with the message sent,
+ *                        or tunneled message. 0, if no channel is associated.
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooOnSendMsg
+   (struct OOH323CallData *call, int msgType, int tunneledMsgType, 
+    int associatedChan);
+
+/**
+ * This function is used to check the status of tcp connection. 
+ * @param call     Handle to the call to which connection belongs.
+ * @param sock     Connected socket.
+ *
+ * @return         True if connection is ok, false otherwise.
+ */
+EXTERN OOBOOL ooChannelsIsConnectionOK(OOH323CallData *call, OOSOCKET sock);
+
+/** 
+ * @} 
+ */
+#ifdef __cplusplus
+}
+#endif
+#endif
+
diff --git a/addons/ooh323c/src/ooh245.c b/addons/ooh323c/src/ooh245.c
new file mode 100644
index 000000000..35d1fe1b0
--- /dev/null
+++ b/addons/ooh323c/src/ooh245.c
@@ -0,0 +1,3686 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooh245.h"
+#include "ooCalls.h"
+#include "printHandler.h"
+#include "ooh323ep.h"
+#include "ooCapability.h"
+#include "ooTimer.h"
+#ifdef _WIN32
+#include <stdlib.h>
+#include <process.h>
+#define getpid _getpid
+#endif
+#include <time.h>
+
+/** Global endpoint structure */
+extern ooEndPoint gH323ep;
+
+static ASN1OBJID gh245ProtocolID = {
+  6, { 0, 0, 8, 245, 0, 8 }
+};
+
+int ooCreateH245Message(H245Message **pph245msg, int type)
+{
+   OOCTXT* pctxt = &gH323ep.msgctxt;
+
+   *pph245msg = (H245Message*) memAlloc (pctxt, sizeof(H245Message));
+
+   if(!(*pph245msg))
+   {
+      OOTRACEERR1("ERROR:Failed to allocate memory for h245 message\n");
+      return OO_FAILED;
+   }
+   else
+   {
+      (*pph245msg)->h245Msg.t = type;
+      (*pph245msg)->logicalChannelNo = 0;
+      switch(type)
+      {
+         case  T_H245MultimediaSystemControlMessage_request:
+            (*pph245msg)->h245Msg.u.request = (H245RequestMessage*) 
+            memAllocZ (pctxt, sizeof(H245RequestMessage));
+
+            /*Check for successful mem allocation, and if successful initialize
+              mem to zero*/
+            if(!(*pph245msg)->h245Msg.u.request)
+            {
+               OOTRACEERR1("ERROR:Memory allocation for H.245 request"
+                                     " message failed\n");
+               return OO_FAILED;
+            }
+            break;
+
+         case T_H245MultimediaSystemControlMessage_response:
+            (*pph245msg)->h245Msg.u.response = (H245ResponseMessage*)
+            memAllocZ (pctxt, sizeof(H245ResponseMessage));
+
+            /*Check for successful mem allocation, and if successful initialize
+              mem to zero*/
+            if(!(*pph245msg)->h245Msg.u.response)
+            {
+               OOTRACEERR1("ERROR:Memory allocation for H.245 response"
+                                     " message failed\n");
+               return OO_FAILED;
+            }
+            break;
+
+         case T_H245MultimediaSystemControlMessage_command:
+            (*pph245msg)->h245Msg.u.command = (H245CommandMessage*)
+            memAllocZ (pctxt, sizeof(H245CommandMessage));
+
+            /*Check for successful mem allocation, and if successful initialize
+              mem to zero*/
+            if(!(*pph245msg)->h245Msg.u.command)
+            {
+               OOTRACEERR1("ERROR:Memory allocation for H.245 command"
+                                     " message failed\n");
+               return OO_FAILED;
+            }
+            break;
+
+         case T_H245MultimediaSystemControlMessage_indication:
+            (*pph245msg)->h245Msg.u.indication = (H245IndicationMessage*)
+            memAllocZ (pctxt, sizeof(H245IndicationMessage));
+
+            /*Check for successful mem allocation, and if successful initialize
+              mem to zero*/
+            if(!(*pph245msg)->h245Msg.u.indication)
+            {
+               OOTRACEERR1("ERROR:Memory allocation for H.245 indication"
+                                     " message failed\n");
+               return OO_FAILED;
+            }
+            break;
+
+         default:
+            OOTRACEERR1("ERROR: H245 message type not supported\n");
+      }
+
+      return OO_OK;
+   }
+}
+
+int ooFreeH245Message(OOH323CallData *call, H245Message *pmsg)
+{
+  /* In case of tunneling, memory is freed when corresponding Q931 message is freed.*/
+   OOTRACEDBGC1("msgCtxt Reset?");
+   if (0 != pmsg) {
+     if(!OO_TESTFLAG (call->flags, OO_M_TUNNELING)){
+         memReset (&gH323ep.msgctxt);
+         OOTRACEDBGC3(" Done (%s, %s)\n", call->callType, call->callToken);
+         return OO_OK;
+     }
+   }
+   OOTRACEDBGC3("Not Done (%s, %s)\n", call->callType, call->callToken);
+   return OO_OK;
+}
+
+#ifndef _COMPACT
+static void ooPrintH245Message 
+   (OOH323CallData* call, ASN1OCTET* msgbuf, ASN1UINT msglen)
+{
+   OOCTXT ctxt;
+   H245MultimediaSystemControlMessage mmMsg;
+   int ret;
+
+   initContext (&ctxt);
+
+   setPERBuffer (&ctxt, msgbuf, msglen, TRUE);
+
+   initializePrintHandler(&printHandler, "Sending H.245 Message");
+
+   /* Set event handler */
+   setEventHandler (&ctxt, &printHandler);
+
+   ret = asn1PD_H245MultimediaSystemControlMessage(&ctxt, &mmMsg);
+   if(ret != ASN_OK)
+   {
+      OOTRACEERR3("Error decoding H245 message (%s, %s)\n", 
+                  call->callType, call->callToken);
+      OOTRACEERR1 (errGetText (&ctxt));
+   }
+   finishPrint();
+   freeContext(&ctxt);   
+}
+#endif
+
+int ooEncodeH245Message
+   (OOH323CallData *call, H245Message *ph245Msg, char *msgbuf, int size)
+{
+   int len=0, encodeLen=0, i=0;
+   int stat=0;
+   ASN1OCTET* encodePtr=NULL;
+   H245MultimediaSystemControlMessage *multimediaMsg;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   multimediaMsg = &(ph245Msg->h245Msg);
+
+   if(!msgbuf || size<200)
+   {
+      OOTRACEERR3("Error: Invalid message buffer/size for "
+                  "ooEncodeH245Message. (%s, %s)\n", 
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   msgbuf[i++] = ph245Msg->msgType;
+   msgbuf[i++] = (ph245Msg->logicalChannelNo>>8);
+   msgbuf[i++] = ph245Msg->logicalChannelNo;
+   /* This will contain the total length of the encoded message */
+   msgbuf[i++] = 0;
+   msgbuf[i++] = 0;
+   
+   if(!OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+   {
+      /* Populate message buffer to be returned */
+      len =  4;
+      msgbuf[i++] = 3; /* TPKT version */
+      msgbuf[i++] = 0; /* TPKT resevred */
+      /* 1st octet of length, will be populated once len is determined */
+      msgbuf[i++] = 0; 
+      /* 2nd octet of length, will be populated once len is determined */
+      msgbuf[i++] = 0;
+   }
+   
+   setPERBuffer (pctxt, msgbuf+i, (size-i), TRUE);
+
+   stat = asn1PE_H245MultimediaSystemControlMessage (&gH323ep.msgctxt, 
+                                                            multimediaMsg);
+
+   if (stat != ASN_OK) {
+      OOTRACEERR3 ("ERROR: H245 Message encoding failed (%s, %s)\n", 
+                   call->callType, call->callToken);
+      OOTRACEERR1 (errGetText (&gH323ep.msgctxt));
+      return OO_FAILED;
+   }
+   
+   encodePtr = encodeGetMsgPtr(pctxt, &encodeLen);
+   len +=encodeLen;
+   msgbuf[3] = (len>>8);
+   msgbuf[4] = len;
+   if(!OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+   {
+      msgbuf[7] = len>>8;
+      msgbuf[8] = len;
+   }
+#ifndef _COMPACT
+   ooPrintH245Message (call, encodePtr, encodeLen);
+#endif
+   return OO_OK;
+}
+
+int ooSendH245Msg(OOH323CallData *call, H245Message *msg)
+{
+   int iRet=0,  len=0, msgType=0, logicalChannelNo = 0;
+   ASN1OCTET * encodebuf;
+
+
+   if(!call)
+      return OO_FAILED;
+
+   encodebuf = (ASN1OCTET*) memAlloc (call->pctxt, MAXMSGLEN);
+   if(!encodebuf)
+   {
+      OOTRACEERR3("Error:Failed to allocate memory for encoding H245 "
+                  "message(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   iRet = ooEncodeH245Message(call, msg, encodebuf, MAXMSGLEN);
+
+   if(iRet != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to encode H245 message. (%s, %s)\n", 
+                                             call->callType, call->callToken);
+      memFreePtr (call->pctxt, encodebuf);
+      return OO_FAILED;
+   }
+   if(!call->pH245Channel)
+   {
+      call->pH245Channel =  
+              (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel));
+      if(!call->pH245Channel)
+      {
+         OOTRACEERR3("Error:Failed to allocate memory for H245Channel "
+                     "structure. (%s, %s)\n", call->callType, call->callToken);
+         memFreePtr (call->pctxt, encodebuf);
+         return OO_FAILED;
+      }
+   }
+
+   /* We need to send EndSessionCommand immediately.*/      
+   if(!OO_TESTFLAG(call->flags, OO_M_TUNNELING)){
+      if(encodebuf[0]== OOEndSessionCommand) /* High priority message */
+      {
+         dListFreeAll(call->pctxt, &call->pH245Channel->outQueue);
+         dListAppend (call->pctxt, &call->pH245Channel->outQueue, encodebuf);
+         ooSendMsg(call, OOH245MSG);
+      }
+      else{
+         dListAppend (call->pctxt, &call->pH245Channel->outQueue, encodebuf);
+         OOTRACEDBGC4("Queued H245 messages %d. (%s, %s)\n", 
+         call->pH245Channel->outQueue.count, 
+         call->callType, call->callToken);   
+      }
+   }
+   else{
+      msgType = encodebuf[0];
+
+      logicalChannelNo = encodebuf[1];
+      logicalChannelNo = logicalChannelNo << 8;
+      logicalChannelNo = (logicalChannelNo | encodebuf[2]);
+
+      len = encodebuf[3];
+      len = len<<8;
+      len = (len | encodebuf[4]);
+
+      iRet = ooSendAsTunneledMessage
+         (call, encodebuf+5,len,msgType, logicalChannelNo);
+
+      if(iRet != OO_OK)
+      {
+         memFreePtr (call->pctxt, encodebuf);
+         OOTRACEERR3("ERROR:Failed to tunnel H.245 message (%s, %s)\n",
+                      call->callType, call->callToken);
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_INVALIDMESSAGE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+      memFreePtr (call->pctxt, encodebuf);
+      return OO_OK;
+   }
+
+   return OO_OK;
+}
+
+int ooSendTermCapMsg(OOH323CallData *call)
+{
+   int ret;
+   H245RequestMessage *request=NULL;
+   OOCTXT *pctxt=NULL;
+   ooH323EpCapability *epCap=NULL;
+   H245TerminalCapabilitySet *termCap=NULL;
+   H245AudioCapability *audioCap=NULL;
+   H245AudioTelephonyEventCapability *ateCap=NULL;
+   H245UserInputCapability *userInputCap = NULL;
+   H245CapabilityTableEntry *entry=NULL;
+   H245AlternativeCapabilitySet *altSet=NULL;
+   H245CapabilityDescriptor *capDesc=NULL;
+   H245Message *ph245msg=NULL;
+   H245VideoCapability *videoCap=NULL;
+
+   int i=0, j=0, k=0;
+   if(call->localTermCapState == OO_LocalTermCapSetSent)
+   {
+      OOTRACEINFO3("TerminalCapabilitySet exchange procedure already in "
+                   "progress. (%s, %s)\n", call->callType, call->callToken);
+      return OO_OK;
+   }
+ 
+   ret = ooCreateH245Message(&ph245msg,  
+                             T_H245MultimediaSystemControlMessage_request);
+ 
+   if(ret == OO_FAILED)
+   {
+      OOTRACEERR3("Error:Failed to create H245 message for Terminal "
+                  "CapabilitySet (%s, %s)\n", call->callType,call->callToken);
+      return OO_FAILED;
+   }
+
+  /* Set request type as TerminalCapabilitySet */
+   request = ph245msg->h245Msg.u.request;
+   pctxt = &gH323ep.msgctxt;
+   ph245msg->msgType = OOTerminalCapabilitySet;
+   memset(request, 0, sizeof(H245RequestMessage));
+   if(request == NULL)
+   {
+      OOTRACEERR3("ERROR: No memory allocated for request message (%s, %s)\n",
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   
+   request->t = T_H245RequestMessage_terminalCapabilitySet;
+   request->u.terminalCapabilitySet = (H245TerminalCapabilitySet*)
+                  memAlloc(pctxt, sizeof(H245TerminalCapabilitySet)); 
+   termCap = request->u.terminalCapabilitySet;
+   memset(termCap, 0, sizeof(H245TerminalCapabilitySet));
+   termCap->m.multiplexCapabilityPresent = 0;
+   termCap->m.capabilityTablePresent = 1;
+   termCap->m.capabilityDescriptorsPresent = 1;
+   termCap->sequenceNumber = ++(call->localTermCapSeqNo);  
+   termCap->protocolIdentifier = gh245ProtocolID; /* protocol id */
+
+   /* Add audio Capabilities */
+ 
+   dListInit(&(termCap->capabilityTable));
+   for(k=0; k<(int)call->capPrefs.index; k++)
+   {
+      if(call->ourCaps)
+         epCap = call->ourCaps;
+      else
+         epCap = gH323ep.myCaps;
+      while(epCap) { 
+         if(epCap->cap == call->capPrefs.order[k]) 
+            break;
+         epCap = epCap->next;
+      }
+      if(!epCap)
+      {
+         OOTRACEWARN4("WARN:Preferred capability %d not supported.(%s, %s)\n",
+                     call->capPrefs.order[k],call->callType, call->callToken);
+         continue;
+      }
+
+      if(epCap->capType == OO_CAP_TYPE_AUDIO)
+      {
+
+         /* Create audio capability. If capability supports receive, we only 
+            add it as receive capability in TCS. However, if it supports only 
+            transmit, we add it as transmit capability in TCS.
+         */
+         if((epCap->dir & OORX))
+         {
+
+            OOTRACEDBGC4("Sending receive capability %s in TCS.(%s, %s)\n",
+                ooGetCapTypeText(epCap->cap), call->callType, call->callToken);
+
+            audioCap = ooCapabilityCreateAudioCapability(epCap, pctxt, OORX);
+            if(!audioCap)
+            {
+               OOTRACEWARN4("WARN:Failed to create audio capability %s "
+                            "(%s, %s)\n", ooGetCapTypeText(epCap->cap), 
+                            call->callType, call->callToken);
+               continue;
+            }
+         }
+         else if(epCap->dir & OOTX)
+         {
+            OOTRACEDBGC4("Sending transmit capability %s in TCS.(%s, %s)\n",
+                ooGetCapTypeText(epCap->cap), call->callType, call->callToken);
+            audioCap = ooCapabilityCreateAudioCapability(epCap, pctxt, OOTX);
+            if(!audioCap)
+            {
+               OOTRACEWARN4("WARN:Failed to create audio capability %s "
+                            "(%s, %s)\n", ooGetCapTypeText(epCap->cap),
+                            call->callType, call->callToken);
+               continue;
+            }     
+         }
+         else{
+            OOTRACEWARN3("Warn:Capability is not RX/TX/RXANDTX. Symmetric "
+                         "capabilities are not supported.(%s, %s)\n", 
+                         call->callType, call->callToken);
+            continue;
+         }
+         /* Add  Capabilities to Capability Table */
+         entry = (H245CapabilityTableEntry*) memAlloc(pctxt,
+                         sizeof(H245CapabilityTableEntry));
+         if(!entry)
+         {
+            OOTRACEERR3("Error:Memory - ooSendTermCapMsg - entry(audio Cap)."
+                        "(%s, %s)\n", call->callType, call->callToken);
+            return OO_FAILED;
+         }
+         memset(entry, 0, sizeof(H245CapabilityTableEntry));
+         entry->m.capabilityPresent = 1;
+         if((epCap->dir & OORX))
+         {
+            entry->capability.t = T_H245Capability_receiveAudioCapability;
+            entry->capability.u.receiveAudioCapability = audioCap;
+         }
+         else{
+            entry->capability.t = T_H245Capability_transmitAudioCapability;
+            entry->capability.u.transmitAudioCapability = audioCap;
+         }
+         entry->capabilityTableEntryNumber = i+1;
+         dListAppend(pctxt , &(termCap->capabilityTable), entry);
+         i++;
+      }
+      else if(epCap->capType == OO_CAP_TYPE_VIDEO)
+      {
+         if((epCap->dir & OORX))
+         {
+            OOTRACEDBGC4("Sending receive capability %s in TCS.(%s, %s)\n",
+                ooGetCapTypeText(epCap->cap), call->callType, call->callToken);
+            videoCap = ooCapabilityCreateVideoCapability(epCap, pctxt, OORX);
+            if(!videoCap)
+            {
+               OOTRACEWARN4("WARN:Failed to create Video capability %s "
+                            "(%s, %s)\n", ooGetCapTypeText(epCap->cap),
+                           call->callType, call->callToken);
+               continue;
+            }
+         }
+         else if(epCap->dir & OOTX)
+         {
+            OOTRACEDBGC4("Sending transmit capability %s in TCS.(%s, %s)\n",
+                ooGetCapTypeText(epCap->cap), call->callType, call->callToken);
+            videoCap = ooCapabilityCreateVideoCapability(epCap, pctxt, OOTX);
+            if(!videoCap)
+            {
+               OOTRACEWARN4("WARN:Failed to create video capability %s "
+                            "(%s, %s)\n", ooGetCapTypeText(epCap->cap),
+                           call->callType, call->callToken);
+               continue;
+            }     
+         }
+         else{
+            OOTRACEWARN3("Warn:Capability is not RX/TX/RXANDTX. Symmetric "
+                         "capabilities are not supported.(%s, %s)\n", 
+                         call->callType, call->callToken);
+            continue;
+         }
+         /* Add Video capabilities to Capability Table */
+         entry = (H245CapabilityTableEntry*) memAlloc(pctxt,
+                            sizeof(H245CapabilityTableEntry));
+         if(!entry)
+         {
+            OOTRACEERR3("Error:Memory - ooSendTermCapMsg - entry(video Cap)."
+                        "(%s, %s)\n", call->callType, call->callToken);
+            return OO_FAILED;
+         }
+         memset(entry, 0, sizeof(H245CapabilityTableEntry));
+         entry->m.capabilityPresent = 1;
+         if((epCap->dir & OORX))
+         {
+            entry->capability.t = T_H245Capability_receiveVideoCapability;
+            entry->capability.u.receiveVideoCapability = videoCap;
+         }
+         else{
+            entry->capability.t = T_H245Capability_transmitVideoCapability;
+            entry->capability.u.transmitVideoCapability = videoCap;
+         }
+         entry->capabilityTableEntryNumber = i+1;
+         dListAppend(pctxt , &(termCap->capabilityTable), entry);
+         i++;
+      }
+   }
+   /* Add dtmf capability, if any */
+   if(call->dtmfmode & OO_CAP_DTMF_RFC2833)
+   {
+      ateCap = (H245AudioTelephonyEventCapability*)
+                  ooCapabilityCreateDTMFCapability(OO_CAP_DTMF_RFC2833, pctxt);
+      if(!ateCap)
+      {
+         OOTRACEWARN3("WARN:Failed to add RFC2833 cap to TCS(%s, %s)\n",
+                     call->callType, call->callToken);
+      }
+      else {
+         entry = (H245CapabilityTableEntry*) memAlloc(pctxt,
+                      sizeof(H245CapabilityTableEntry));
+         if(!entry)
+         {
+            OOTRACEERR3("Error:Failed to allocate memory for new capability "
+                        "table entry. (%s, %s)\n", call->callType, 
+                        call->callToken);
+            ooFreeH245Message(call, ph245msg);
+            return OO_FAILED;
+         }
+            
+         memset(entry, 0, sizeof(H245CapabilityTableEntry));
+         entry->m.capabilityPresent = 1;
+
+         entry->capability.t = T_H245Capability_receiveRTPAudioTelephonyEventCapability;
+         entry->capability.u.receiveRTPAudioTelephonyEventCapability = ateCap;
+      
+         entry->capabilityTableEntryNumber = i+1;
+         dListAppend(pctxt , &(termCap->capabilityTable), entry);
+
+         i++;
+      }
+   }
+
+   if(call->dtmfmode & OO_CAP_DTMF_H245_alphanumeric)
+   {
+      userInputCap = (H245UserInputCapability*)ooCapabilityCreateDTMFCapability
+                                        (OO_CAP_DTMF_H245_alphanumeric, pctxt);
+      if(!userInputCap)
+      {
+         OOTRACEWARN3("WARN:Failed to add H245(alphanumeric) cap to "
+                      "TCS(%s, %s)\n", call->callType, call->callToken);
+      }
+      else {
+         entry = (H245CapabilityTableEntry*) memAlloc(pctxt,
+                      sizeof(H245CapabilityTableEntry));
+         if(!entry)
+         {
+            OOTRACEERR3("Error:Failed to allocate memory for new capability "
+                        "table entry. (%s, %s)\n", call->callType, 
+                        call->callToken);
+            ooFreeH245Message(call, ph245msg);
+            return OO_FAILED;
+         }
+            
+         memset(entry, 0, sizeof(H245CapabilityTableEntry));
+         entry->m.capabilityPresent = 1;
+
+         entry->capability.t = T_H245Capability_receiveUserInputCapability;
+         entry->capability.u.receiveUserInputCapability = userInputCap;
+      
+         entry->capabilityTableEntryNumber = i+1;
+         dListAppend(pctxt , &(termCap->capabilityTable), entry);
+
+         i++;
+      }
+   }
+   userInputCap = NULL;
+   if(call->dtmfmode & OO_CAP_DTMF_H245_signal)
+   {
+      userInputCap = (H245UserInputCapability*)ooCapabilityCreateDTMFCapability
+                                        (OO_CAP_DTMF_H245_signal, pctxt);
+      if(!userInputCap)
+      {
+         OOTRACEWARN3("WARN:Failed to add H245(signal) cap to "
+                      "TCS(%s, %s)\n", call->callType, call->callToken);
+      }
+      else {
+         entry = (H245CapabilityTableEntry*) memAlloc(pctxt,
+                      sizeof(H245CapabilityTableEntry));
+         if(!entry)
+         {
+            OOTRACEERR3("Error:Failed to allocate memory for new capability "
+                        "table entry. (%s, %s)\n", call->callType, 
+                        call->callToken);
+            ooFreeH245Message(call, ph245msg);
+            return OO_FAILED;
+         }
+            
+         memset(entry, 0, sizeof(H245CapabilityTableEntry));
+         entry->m.capabilityPresent = 1;
+
+         entry->capability.t = T_H245Capability_receiveUserInputCapability;
+         entry->capability.u.receiveUserInputCapability = userInputCap;
+      
+         entry->capabilityTableEntryNumber = i+1;
+         dListAppend(pctxt , &(termCap->capabilityTable), entry);
+
+         i++;
+      }
+   }
+
+          
+   /*TODO:Add Video and Data capabilities, if required*/
+   if(i==0)
+   {
+      OOTRACEERR3("Error:No capabilities found to send in TCS message."
+                  " (%s, %s)\n", call->callType, call->callToken);
+      ooFreeH245Message(call,ph245msg);
+      return OO_FAILED;
+   }
+      
+   /* Define capability descriptior */
+   capDesc = (H245CapabilityDescriptor*)
+             memAlloc(pctxt, sizeof(H245CapabilityDescriptor));
+   memset(capDesc, 0, sizeof(H245CapabilityDescriptor));
+   capDesc->m.simultaneousCapabilitiesPresent = 1;
+   capDesc->capabilityDescriptorNumber = 1;
+   dListInit(&(capDesc->simultaneousCapabilities));
+   /* Add Alternative Capability Set.
+      TODO: Right now all capabilities are added in separate
+            alternate capabilities set. Need a way for application
+            developer to specify the alternative capability sets.
+   */
+   for(j=0; j<i; j++)
+   {
+      altSet = (H245AlternativeCapabilitySet*)
+               memAlloc(pctxt, sizeof(H245AlternativeCapabilitySet));
+      memset(altSet, 0, sizeof(H245AlternativeCapabilitySet));
+      altSet->n = 1;
+      altSet->elem[0] = j+1;
+   
+      dListAppend(pctxt, &(capDesc->simultaneousCapabilities), altSet);
+   }
+
+   dListInit(&(termCap->capabilityDescriptors));
+   dListAppend(pctxt, &(termCap->capabilityDescriptors), capDesc);
+
+   OOTRACEDBGA3("Built terminal capability set message (%s, %s)\n", 
+                 call->callType, call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue TCS message to outbound queue. "
+                  "(%s, %s)\n", call->callType, call->callToken);
+   }
+   else {
+      call->localTermCapState = OO_LocalTermCapSetSent;
+   }
+
+   ooFreeH245Message(call,ph245msg);
+
+   return ret;
+}
+
+
+ASN1UINT ooGenerateStatusDeterminationNumber()
+{
+   ASN1UINT statusDeterminationNumber;
+   ASN1UINT random_factor = getpid();
+
+#ifdef _WIN32
+   SYSTEMTIME systemTime;
+   GetLocalTime(&systemTime);
+   srand((systemTime.wMilliseconds ^ systemTime.wSecond) + random_factor);
+#else
+   struct timeval tv;
+   gettimeofday(&tv, NULL);
+   srand((tv.tv_usec ^ tv.tv_sec) + random_factor );
+#endif
+
+   statusDeterminationNumber = rand()%16777215;
+   return statusDeterminationNumber;
+}
+/* TODO: Should Send MasterSlave Release when no response from 
+         Remote endpoint after MasterSlaveDetermination sent within
+         timeout.
+*/
+int ooHandleMasterSlave(OOH323CallData *call, void * pmsg, 
+                          int msgType)
+{
+   H245MasterSlaveDetermination *masterSlave;
+   H245MasterSlaveDeterminationAck *masterSlaveAck;
+   ASN1UINT statusDeterminationNumber;
+
+   switch(msgType)
+   {
+      case OOMasterSlaveDetermination:
+         OOTRACEINFO3("Master Slave Determination received (%s, %s)\n",
+                       call->callType, call->callToken);
+         
+         masterSlave = (H245MasterSlaveDetermination*)pmsg;
+         
+         if(masterSlave->terminalType < gH323ep.termType)
+         {
+            ooSendMasterSlaveDeterminationAck(call, "slave");
+            call->masterSlaveState =  OO_MasterSlave_Master;
+            OOTRACEINFO3("MasterSlaveDetermination done - Master(%s, %s)\n",
+                             call->callType, call->callToken);
+            return OO_OK;
+         }
+         if(masterSlave->terminalType > gH323ep.termType)
+         {
+            ooSendMasterSlaveDeterminationAck(call, "master");
+            call->masterSlaveState =  OO_MasterSlave_Slave;
+            OOTRACEINFO3("MasterSlaveDetermination done - Slave(%s, %s)\n",
+                             call->callType, call->callToken);
+            return OO_OK;
+         }
+         /* Since term types are same, master slave determination will
+            be done based on statusdetermination number
+         */
+         
+         OOTRACEDBGA3("Determining master-slave based on StatusDetermination"
+                      "Number (%s, %s)\n", call->callType, call->callToken);
+         if(call->masterSlaveState == OO_MasterSlave_DetermineSent)
+            statusDeterminationNumber = call->statusDeterminationNumber;
+         else
+            statusDeterminationNumber = ooGenerateStatusDeterminationNumber();
+         
+         if(masterSlave->statusDeterminationNumber < 
+                       statusDeterminationNumber)
+         {
+            ooSendMasterSlaveDeterminationAck(call, "slave");
+            call->masterSlaveState =  OO_MasterSlave_Master;
+            OOTRACEINFO3("MasterSlaveDetermination done - Master(%s, %s)\n",
+                             call->callType, call->callToken);
+            return OO_OK;
+         }
+         if(masterSlave->statusDeterminationNumber > 
+                         statusDeterminationNumber)
+         {
+            ooSendMasterSlaveDeterminationAck(call, "master");
+            call->masterSlaveState =  OO_MasterSlave_Slave;
+            OOTRACEINFO3("MasterSlaveDetermination done - Slave(%s, %s)\n",
+                             call->callType, call->callToken);
+            return OO_OK;
+         }
+         if(masterSlave->statusDeterminationNumber == 
+                         statusDeterminationNumber)
+         {
+            ooSendMasterSlaveDeterminationReject (call);
+
+            OOTRACEERR3("ERROR:MasterSlaveDetermination failed- identical "
+                        "numbers (%s, %s)\n", call->callType, call->callToken);
+         }
+         break;
+
+      case OOMasterSlaveAck:
+         masterSlaveAck = (H245MasterSlaveDeterminationAck*)pmsg;
+         if(call->masterSlaveState == OO_MasterSlave_DetermineSent)
+         {
+            if(masterSlaveAck->decision.t == 
+               T_H245MasterSlaveDeterminationAck_decision_master)
+            {
+               ooSendMasterSlaveDeterminationAck(call, "slave");
+               call->masterSlaveState =  OO_MasterSlave_Master;
+               OOTRACEINFO3("MasterSlaveDetermination done - Master(%s, %s)\n",
+                             call->callType, call->callToken);
+            }
+            else
+            {
+               ooSendMasterSlaveDeterminationAck(call, "master");
+               call->masterSlaveState = OO_MasterSlave_Slave;
+               OOTRACEINFO3("MasterSlaveDetermination done - Slave(%s, %s)\n",
+                             call->callType, call->callToken);
+            }
+         }
+         
+         if(call->localTermCapState == OO_LocalTermCapSetAckRecvd &&
+            call->remoteTermCapState == OO_RemoteTermCapSetAckSent)
+         {
+            /*Since Cap exchange and MasterSlave Procedures are done */
+            if(gH323ep.h323Callbacks.openLogicalChannels)
+               gH323ep.h323Callbacks.openLogicalChannels(call);
+            else{
+               if(!call->logicalChans)
+                  ooOpenLogicalChannels(call);
+            }
+#if 0
+            if(!call->logicalChans){
+               if(!gH323ep.h323Callbacks.openLogicalChannels)
+                  ooOpenLogicalChannels(call);
+               else
+                  gH323ep.h323Callbacks.openLogicalChannels(call);
+            }
+#endif
+         }
+         else
+            OOTRACEDBGC1("Not opening logical channels as Cap exchange "
+                         "remaining\n");
+         break;
+       default:
+          OOTRACEWARN3("Warn:Unhandled Master Slave message received - %s - "
+                       "%s\n", call->callType, call->callToken);
+   }
+   return OO_OK;      
+}
+
+int ooSendMasterSlaveDetermination(OOH323CallData *call)
+{
+   int ret;
+   H245Message* ph245msg=NULL;
+   H245RequestMessage *request;
+   OOCTXT *pctxt=&gH323ep.msgctxt;
+   H245MasterSlaveDetermination* pMasterSlave;
+
+   /* Check whether Master Slave Determination already in progress */
+   if(call->masterSlaveState != OO_MasterSlave_Idle)
+   {
+      OOTRACEINFO3("MasterSlave determination already in progress (%s, %s)\n",
+                   call->callType, call->callToken);
+      return OO_OK;
+   }
+
+   ret = ooCreateH245Message(&ph245msg,
+                   T_H245MultimediaSystemControlMessage_request);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error: creating H245 message - MasterSlave Determination "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOMasterSlaveDetermination;
+   request = ph245msg->h245Msg.u.request;
+   request->t = T_H245RequestMessage_masterSlaveDetermination;
+   request->u.masterSlaveDetermination = (H245MasterSlaveDetermination*)
+            ASN1MALLOC(pctxt, sizeof(H245MasterSlaveDetermination));
+
+   
+   pMasterSlave = request->u.masterSlaveDetermination;
+   memset(pMasterSlave, 0, sizeof(H245MasterSlaveDetermination));   
+   pMasterSlave->terminalType = gH323ep.termType; 
+   pMasterSlave->statusDeterminationNumber = 
+                       ooGenerateStatusDeterminationNumber();
+   call->statusDeterminationNumber = pMasterSlave->statusDeterminationNumber;
+
+   OOTRACEDBGA3("Built MasterSlave Determination (%s, %s)\n", call->callType,
+                 call->callToken); 
+   ret = ooSendH245Msg(call, ph245msg);
+
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue MasterSlaveDetermination message to"
+                  " outbound queue. (%s, %s)\n", call->callType, 
+                  call->callToken);
+   }
+   else
+      call->masterSlaveState = OO_MasterSlave_DetermineSent;
+   
+   ooFreeH245Message(call, ph245msg);
+
+   return ret;
+}
+
+int ooSendMasterSlaveDeterminationAck(OOH323CallData* call,
+                                      char * status)
+{
+   int ret=0;
+   H245ResponseMessage * response=NULL;
+   H245Message *ph245msg=NULL;
+   OOCTXT *pctxt=&gH323ep.msgctxt;
+
+   ret = ooCreateH245Message(&ph245msg, 
+                      T_H245MultimediaSystemControlMessage_response);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:H245 message creation failed for - MasterSlave "
+                  "Determination Ack (%s, %s)\n",call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOMasterSlaveAck;
+   response = ph245msg->h245Msg.u.response;
+   memset(response, 0, sizeof(H245ResponseMessage));
+   response->t = T_H245ResponseMessage_masterSlaveDeterminationAck;
+   response->u.masterSlaveDeterminationAck = (H245MasterSlaveDeterminationAck*)
+                   ASN1MALLOC(pctxt, sizeof(H245MasterSlaveDeterminationAck));
+   memset(response->u.masterSlaveDeterminationAck, 0, 
+                             sizeof(H245MasterSlaveDeterminationAck));
+   if(!strcmp("master", status))
+      response->u.masterSlaveDeterminationAck->decision.t = 
+                         T_H245MasterSlaveDeterminationAck_decision_master;
+   else
+      response->u.masterSlaveDeterminationAck->decision.t = 
+                         T_H245MasterSlaveDeterminationAck_decision_slave;
+   
+   OOTRACEDBGA3("Built MasterSlave determination Ack (%s, %s)\n", 
+                call->callType, call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue MasterSlaveDeterminationAck message"
+                  " to outbound queue. (%s, %s)\n", call->callType, 
+                  call->callToken);
+   }
+   
+   ooFreeH245Message(call, ph245msg);
+   return ret;
+}
+
+int ooSendMasterSlaveDeterminationReject (OOH323CallData* call)
+{
+   int ret=0;
+   H245ResponseMessage* response=NULL;
+   H245Message *ph245msg=NULL;
+   OOCTXT *pctxt=&gH323ep.msgctxt;
+
+   ret = ooCreateH245Message
+      (&ph245msg, T_H245MultimediaSystemControlMessage_response);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3("Error:H245 message creation failed for - MasterSlave "
+                  "Determination Reject (%s, %s)\n",call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOMasterSlaveReject;
+   response = ph245msg->h245Msg.u.response;
+
+   response->t = T_H245ResponseMessage_masterSlaveDeterminationReject;
+
+   response->u.masterSlaveDeterminationReject = 
+      (H245MasterSlaveDeterminationReject*)
+      memAlloc (pctxt, sizeof(H245MasterSlaveDeterminationReject));
+
+   response->u.masterSlaveDeterminationReject->cause.t =
+      T_H245MasterSlaveDeterminationReject_cause_identicalNumbers;
+
+   OOTRACEDBGA3 ("Built MasterSlave determination reject (%s, %s)\n", 
+                 call->callType, call->callToken);
+
+   ret = ooSendH245Msg (call, ph245msg);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3 
+         ("Error:Failed to enqueue MasterSlaveDeterminationReject "
+          "message to outbound queue.(%s, %s)\n", call->callType, 
+          call->callToken);
+   }
+   
+   ooFreeH245Message (call, ph245msg);
+
+   return ret;
+}
+
+int ooSendMasterSlaveDeterminationRelease(OOH323CallData * call)
+{
+   int ret=0;
+   H245IndicationMessage* indication=NULL;
+   H245Message *ph245msg=NULL;
+   OOCTXT *pctxt=&gH323ep.msgctxt;
+
+   ret = ooCreateH245Message
+      (&ph245msg, T_H245MultimediaSystemControlMessage_indication);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3("Error:H245 message creation failed for - MasterSlave "
+                  "Determination Release (%s, %s)\n",call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOMasterSlaveRelease;
+   indication = ph245msg->h245Msg.u.indication;
+
+   indication->t = T_H245IndicationMessage_masterSlaveDeterminationRelease;
+
+   indication->u.masterSlaveDeterminationRelease = 
+      (H245MasterSlaveDeterminationRelease*)
+      memAlloc (pctxt, sizeof(H245MasterSlaveDeterminationRelease));
+
+   if(!indication->u.masterSlaveDeterminationRelease)
+   {
+      OOTRACEERR3("Error: Failed to allocate memory for MSDRelease message."
+                  " (%s, %s)\n", call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   OOTRACEDBGA3 ("Built MasterSlave determination Release (%s, %s)\n", 
+                 call->callType, call->callToken);
+
+   ret = ooSendH245Msg (call, ph245msg);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3 
+        ("Error:Failed to enqueue MasterSlaveDeterminationRelease "
+        "message to outbound queue.(%s, %s)\n", call->callType, 
+        call->callToken);
+   }
+   
+   ooFreeH245Message (call, ph245msg);
+   return ret;
+}
+
+int ooHandleMasterSlaveReject
+   (OOH323CallData *call, H245MasterSlaveDeterminationReject* reject)
+{
+   if(call->msdRetries < DEFAULT_MAX_RETRIES)
+   {
+      call->msdRetries++;
+      OOTRACEDBGA3("Retrying MasterSlaveDetermination. (%s, %s)\n", 
+                    call->callType, call->callToken);
+      call->masterSlaveState = OO_MasterSlave_Idle;
+      ooSendMasterSlaveDetermination(call);
+      return OO_OK;
+   }
+   OOTRACEERR3("Error:Failed to complete MasterSlaveDetermination - "
+               "Ending call. (%s, %s)\n", call->callType, call->callToken);
+   if(call->callState < OO_CALL_CLEAR)
+   {
+      call->callEndReason = OO_REASON_LOCAL_CLEARED;
+      call->callState = OO_CALL_CLEAR;
+   }
+   return OO_OK;
+}
+
+
+int ooHandleOpenLogicalChannel(OOH323CallData* call, 
+                                 H245OpenLogicalChannel *olc)
+{
+
+   H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp =
+    &(olc->forwardLogicalChannelParameters);
+   
+#if 0
+   if(!call->logicalChans)
+      ooOpenLogicalChannels(call);
+#endif
+
+   /* Check whether channel type is supported. Only supported channel 
+      type for now is g711ulaw audio channel.
+   */
+   switch(flcp->dataType.t)
+   {
+   case T_H245DataType_nonStandard:
+      OOTRACEWARN3("Warn:Media channel data type "
+                   "'T_H245DataType_nonStandard' not supported (%s, %s)\n",
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_nullData:
+      OOTRACEWARN3("Warn:Media channel data type "
+                   "'T_H245DataType_nullData' not supported (%s, %s)\n",
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_videoData:
+   case T_H245DataType_audioData:
+      ooHandleOpenLogicalChannel_helper(call, olc);
+      break;
+   case T_H245DataType_data:
+      OOTRACEWARN3("Warn:Media channel data type "
+                   "'T_H245DataType_data' not supported (%s, %s)\n",
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_encryptionData:
+      OOTRACEWARN3("Warn:Media channel data type "
+                   "'T_H245DataType_encryptionData' not supported (%s, %s)\n",
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_h235Control:
+      OOTRACEWARN3("Warn:Media channel data type "
+                   "'T_H245DataType_h235Control' not supported (%s, %s)\n",
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_h235Media:
+      OOTRACEWARN3("Warn:Media channel data type "
+                   "'T_H245DataType_h235Media' not supported (%s, %s)\n",
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_multiplexedStream:
+      OOTRACEWARN3("Warn:Media channel data type "
+                  "'T_H245DataType_multiplexedStream' not supported(%s, %s)\n",
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_redundancyEncoding:
+      OOTRACEWARN3("Warn:Media channel data type "
+                "'T_H245DataType_redundancyEncoding' not supported (%s, %s)\n",
+                  call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_multiplePayloadStream:
+      OOTRACEWARN3("Warn:Media channel data type "
+             "'T_H245DataType_multiplePayloadStream' not supported (%s, %s)\n",
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   case T_H245DataType_fec:
+      OOTRACEWARN3("Warn:Media channel data type 'T_H245DataType_fec' not "
+                   "supported (%s, %s)\n", call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      break;
+   default:
+      OOTRACEERR3("ERROR:Unknown media channel data type (%s, %s)\n", 
+                   call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+             T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+   }
+   
+   return OO_OK;
+}       
+
+/*TODO: Need to clean logical channel in case of failure after creating one */
+int ooHandleOpenLogicalChannel_helper(OOH323CallData *call, 
+                                    H245OpenLogicalChannel*olc)
+{
+   int ret=0;
+   H245Message *ph245msg=NULL;
+   H245ResponseMessage *response;
+   H245OpenLogicalChannelAck *olcAck;
+   ooH323EpCapability *epCap=NULL;
+   H245H2250LogicalChannelAckParameters *h2250lcap=NULL;
+   OOCTXT *pctxt;
+   H245UnicastAddress *unicastAddrs, *unicastAddrs1;
+   H245UnicastAddress_iPAddress *iPAddress, *iPAddress1;
+   ooLogicalChannel *pLogicalChannel = NULL;
+   H245H2250LogicalChannelParameters *h2250lcp=NULL;
+   H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp =
+    &(olc->forwardLogicalChannelParameters);
+
+   if(!flcp || flcp->multiplexParameters.t != T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
+   {
+      OOTRACEERR3("Error:ooHandleOpenLogicalChannel_helper - invalid forward "
+                 "logical channel parameters. (%s, %s)\n", call->callType, 
+                 call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+          T_H245OpenLogicalChannelReject_cause_unspecified);
+      return OO_FAILED;
+   }
+
+   h2250lcp = flcp->multiplexParameters.u.h2250LogicalChannelParameters;
+
+   if(!(epCap=ooIsDataTypeSupported(call, &flcp->dataType, OORX)))
+   {
+      OOTRACEERR3("ERROR:HandleOpenLogicalChannel_helper - capability not "
+                  "supported (%s, %s)\n", call->callType, call->callToken);
+      ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber,
+          T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported);
+      return OO_FAILED;
+   }
+   /* Generate an Ack for the open channel request */
+   ret = ooCreateH245Message(&ph245msg,
+                             T_H245MultimediaSystemControlMessage_response);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error: H245 message creation failed for - "
+                  "OpenLogicalChannel Ack (%s, %s)\n", call->callType, 
+                  call->callToken);
+      memFreePtr(call->pctxt, epCap);
+      epCap = NULL;
+      return OO_FAILED;
+   }
+
+   ph245msg->msgType = OOOpenLogicalChannelAck;
+   ph245msg->logicalChannelNo = olc->forwardLogicalChannelNumber;
+   response = ph245msg->h245Msg.u.response;
+   pctxt = &gH323ep.msgctxt;
+   memset(response, 0, sizeof(H245ResponseMessage));
+   response->t = T_H245ResponseMessage_openLogicalChannelAck;
+   response->u.openLogicalChannelAck = (H245OpenLogicalChannelAck*)
+                   memAlloc(pctxt, sizeof(H245OpenLogicalChannelAck));   
+   olcAck = response->u.openLogicalChannelAck;
+   memset(olcAck, 0, sizeof(H245OpenLogicalChannelAck));
+   olcAck->forwardLogicalChannelNumber = olc->forwardLogicalChannelNumber;
+
+   olcAck->m.forwardMultiplexAckParametersPresent = 1;
+   olcAck->forwardMultiplexAckParameters.t = 
+     T_H245OpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters;
+   olcAck->forwardMultiplexAckParameters.u.h2250LogicalChannelAckParameters = 
+                      (H245H2250LogicalChannelAckParameters*)ASN1MALLOC(pctxt, 
+                      sizeof(H245H2250LogicalChannelAckParameters));
+   h2250lcap = 
+      olcAck->forwardMultiplexAckParameters.u.h2250LogicalChannelAckParameters;
+   memset(h2250lcap, 0, sizeof(H245H2250LogicalChannelAckParameters));
+
+   h2250lcap->m.mediaChannelPresent = 1;
+   h2250lcap->m.mediaControlChannelPresent = 1;
+   h2250lcap->m.sessionIDPresent = 1;
+
+   if(h2250lcp->sessionID == 0)
+      h2250lcap->sessionID = ooCallGenerateSessionID(call, epCap->capType, "receive");
+   else
+      h2250lcap->sessionID = h2250lcp->sessionID;
+   
+   h2250lcap->mediaChannel.t = 
+                         T_H245TransportAddress_unicastAddress;
+   h2250lcap->mediaChannel.u.unicastAddress =  (H245UnicastAddress*)
+                         ASN1MALLOC(pctxt, sizeof(H245UnicastAddress));
+
+   unicastAddrs = h2250lcap->mediaChannel.u.unicastAddress;
+   memset(unicastAddrs, 0, sizeof(H245UnicastAddress));
+   unicastAddrs->t = T_H245UnicastAddress_iPAddress;
+   unicastAddrs->u.iPAddress = (H245UnicastAddress_iPAddress*)
+               memAlloc(pctxt, sizeof(H245UnicastAddress_iPAddress));
+   iPAddress = unicastAddrs->u.iPAddress;
+   memset(iPAddress, 0, sizeof(H245UnicastAddress_iPAddress));
+
+   pLogicalChannel = ooAddNewLogicalChannel(call, 
+                        olc->forwardLogicalChannelNumber, h2250lcap->sessionID,
+                        "receive", epCap);
+   if(!pLogicalChannel)
+   {
+      OOTRACEERR3("ERROR:Failed to add new logical channel entry to call " 
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ooSocketConvertIpToNwAddr(call->localIP, iPAddress->network.data);
+
+   iPAddress->network.numocts = 4;
+   iPAddress->tsapIdentifier = pLogicalChannel->localRtpPort;
+
+   /* media contrcol channel */
+   h2250lcap->mediaControlChannel.t = 
+                                 T_H245TransportAddress_unicastAddress;
+   h2250lcap->mediaControlChannel.u.unicastAddress =  (H245UnicastAddress*)
+                         ASN1MALLOC(pctxt, sizeof(H245UnicastAddress));
+
+   unicastAddrs1 = h2250lcap->mediaControlChannel.u.unicastAddress;
+   memset(unicastAddrs1, 0, sizeof(H245UnicastAddress));
+   unicastAddrs1->t = T_H245UnicastAddress_iPAddress;
+   unicastAddrs1->u.iPAddress = (H245UnicastAddress_iPAddress*)
+               memAlloc(pctxt, sizeof(H245UnicastAddress_iPAddress));
+   iPAddress1 = unicastAddrs1->u.iPAddress;
+   memset(iPAddress1, 0, sizeof(H245UnicastAddress_iPAddress));
+
+   ooSocketConvertIpToNwAddr(call->localIP, iPAddress1->network.data);
+
+   iPAddress1->network.numocts = 4;
+   iPAddress1->tsapIdentifier = pLogicalChannel->localRtcpPort;
+
+   OOTRACEDBGA3("Built OpenLogicalChannelAck (%s, %s)\n", call->callType, 
+                 call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue OpenLogicalChannelAck message to "
+                  "outbound queue. (%s, %s)\n", call->callType, 
+                  call->callToken);
+   }
+   ooFreeH245Message(call, ph245msg);
+
+
+   if(epCap->startReceiveChannel)
+   {
+      epCap->startReceiveChannel(call, pLogicalChannel);      
+      OOTRACEINFO6("Receive channel of type %s started at %s:%d(%s, %s)\n", 
+                    ooGetCapTypeText(epCap->cap), call->localIP, 
+                    pLogicalChannel->localRtpPort, call->callType, 
+                    call->callToken);
+   }
+   else{
+      OOTRACEERR3("ERROR:No callback registered to start receive audio "
+                  "channel (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   pLogicalChannel->state = OO_LOGICALCHAN_ESTABLISHED;
+   return ret;
+}
+
+int ooSendOpenLogicalChannelReject
+   (OOH323CallData *call, ASN1UINT channelNum, ASN1UINT cause)
+{
+   int ret=0;
+   H245ResponseMessage* response=NULL;
+   H245Message *ph245msg=NULL;
+   OOCTXT *pctxt=&gH323ep.msgctxt;
+
+   ret = ooCreateH245Message
+      (&ph245msg, T_H245MultimediaSystemControlMessage_response);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3("Error:H245 message creation failed for - OpenLogicalChannel"
+                  "Reject (%s, %s)\n",call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOOpenLogicalChannelReject;
+   response = ph245msg->h245Msg.u.response;
+
+   response->t = T_H245ResponseMessage_openLogicalChannelReject;
+
+   response->u.openLogicalChannelReject = 
+      (H245OpenLogicalChannelReject*)
+      memAlloc (pctxt, sizeof(H245OpenLogicalChannelReject));
+
+   if(!response->u.openLogicalChannelReject)
+   {
+      OOTRACEERR3("Error: Failed to allocate memory for OpenLogicalChannel"
+                  "Reject message. (%s, %s)\n", call->callType, 
+                  call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   response->u.openLogicalChannelReject->forwardLogicalChannelNumber = 
+                                                                 channelNum;
+   response->u.openLogicalChannelReject->cause.t = cause;
+
+   OOTRACEDBGA3 ("Built OpenLogicalChannelReject (%s, %s)\n", 
+                 call->callType, call->callToken);
+
+   ret = ooSendH245Msg (call, ph245msg);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3 
+         ("Error:Failed to enqueue OpenLogicalChannelReject "
+         "message to outbound queue.(%s, %s)\n", call->callType, 
+         call->callToken);
+   }
+   
+   ooFreeH245Message (call, ph245msg);
+
+   return ret;
+}
+
+
+int ooOnReceivedOpenLogicalChannelAck(OOH323CallData *call,
+                                      H245OpenLogicalChannelAck *olcAck)
+{
+   char remoteip[20];
+   ooLogicalChannel *pLogicalChannel;
+   H245H2250LogicalChannelAckParameters *h2250lcap;
+   H245UnicastAddress *unicastAddr;
+   H245UnicastAddress_iPAddress *iPAddress;
+   H245UnicastAddress *unicastAddr1;
+   H245UnicastAddress_iPAddress *iPAddress1;
+
+   if(!((olcAck->m.forwardMultiplexAckParametersPresent == 1) &&
+        (olcAck->forwardMultiplexAckParameters.t == 
+         T_H245OpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters)))
+   {
+      OOTRACEERR3("Error: Processing open logical channel ack - LogicalChannel"
+                  "Ack parameters absent (%s, %s)\n", call->callType, 
+                  call->callToken);
+      return OO_OK;  /* should send CloseLogicalChannel request */
+   }
+
+   h2250lcap = 
+      olcAck->forwardMultiplexAckParameters.u.h2250LogicalChannelAckParameters;
+   /* Extract media channel address */
+   if(h2250lcap->m.mediaChannelPresent != 1)
+   { 
+      OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media channel "
+                  "absent (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   if(h2250lcap->mediaChannel.t != T_H245TransportAddress_unicastAddress)
+   {
+      OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media channel "
+                  "address type is not unicast (%s, %s)\n", call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   
+   unicastAddr = h2250lcap->mediaChannel.u.unicastAddress;
+   if(unicastAddr->t != T_H245UnicastAddress_iPAddress)
+   {
+      OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media channel "
+                  "address type is not IP (%s, %s)\n", call->callType, 
+                   call->callToken);
+      return OO_FAILED;
+   }
+   iPAddress = unicastAddr->u.iPAddress;
+   
+   sprintf(remoteip,"%d.%d.%d.%d", iPAddress->network.data[0],
+                                  iPAddress->network.data[1], 
+                                  iPAddress->network.data[2], 
+                                  iPAddress->network.data[3]);
+   
+   /* Extract media control channel address */
+   if(h2250lcap->m.mediaControlChannelPresent != 1)
+   { 
+      OOTRACEERR3("Error: Processing OpenLogicalChannelAck - Missing media "
+                "control channel (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   if(h2250lcap->mediaControlChannel.t != 
+                                     T_H245TransportAddress_unicastAddress)
+   {
+      OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media control "
+                  "channel addres type is not unicast (%s, %s)\n", 
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   
+   unicastAddr1 = h2250lcap->mediaControlChannel.u.unicastAddress;
+   if(unicastAddr1->t != T_H245UnicastAddress_iPAddress)
+   {
+      OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media control "
+                  "channel address type is not IP (%s, %s)\n", call->callType, 
+                   call->callToken);
+      return OO_FAILED;
+   }
+   iPAddress1 = unicastAddr1->u.iPAddress;
+
+   /* Set remote destination address for rtp session */
+   //   strcpy(call->remoteIP, remoteip);
+   
+   /* Start channel here */
+   pLogicalChannel = ooFindLogicalChannelByLogicalChannelNo(call,olcAck->forwardLogicalChannelNumber);
+   if(!pLogicalChannel)
+   {
+      OOTRACEERR4("ERROR:Logical channel %d not found in the channel list for "
+                  "call (%s, %s)\n", olcAck->forwardLogicalChannelNumber, 
+                  call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   /* Update session id if we were waiting for remote to assign one and remote 
+      did assign one. */
+   if(pLogicalChannel->sessionID == 0 && h2250lcap->m.sessionIDPresent)
+      pLogicalChannel->sessionID = h2250lcap->sessionID;   
+
+   /* Populate ports &ip  for channel */
+   strcpy(pLogicalChannel->remoteIP, remoteip);   
+   pLogicalChannel->remoteMediaPort = iPAddress->tsapIdentifier;
+   pLogicalChannel->remoteMediaControlPort = iPAddress1->tsapIdentifier;
+
+   if(pLogicalChannel->chanCap->startTransmitChannel)
+   {
+      pLogicalChannel->chanCap->startTransmitChannel(call, pLogicalChannel);
+      OOTRACEINFO4("TransmitLogical Channel of type %s started (%s, %s)\n", 
+                   ooGetCapTypeText(pLogicalChannel->chanCap->cap),
+                   call->callType, call->callToken);
+   }
+   else{
+      OOTRACEERR3("ERROR:No callback registered for starting transmit channel "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   pLogicalChannel->state = OO_LOGICALCHAN_ESTABLISHED;
+   return OO_OK;
+}
+
+int ooOnReceivedOpenLogicalChannelRejected(OOH323CallData *call, 
+                                     H245OpenLogicalChannelReject *olcReject)
+{
+   switch(olcReject->cause.t)
+   {
+   case T_H245OpenLogicalChannelReject_cause_unspecified:
+      OOTRACEINFO4("Open logical channel %d rejected - unspecified (%s, %s)\n",
+                   olcReject->forwardLogicalChannelNumber, call->callType, 
+                   call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_unsuitableReverseParameters:
+      OOTRACEINFO4("Open logical channel %d rejected - "
+                   "unsuitableReverseParameters (%s, %s)\n", 
+                   olcReject->forwardLogicalChannelNumber, call->callType, 
+                   call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported:
+      OOTRACEINFO4("Open logical channel %d rejected - dataTypeNotSupported"
+                   "(%s, %s)\n", olcReject->forwardLogicalChannelNumber, 
+                   call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_dataTypeNotAvailable:
+      OOTRACEINFO4("Open logical channel %d rejected - dataTypeNotAvailable"
+                   "(%s, %s)\n", olcReject->forwardLogicalChannelNumber, 
+                   call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_unknownDataType:
+      OOTRACEINFO4("Open logical channel %d rejected - unknownDataType"
+                   "(%s, %s)\n", olcReject->forwardLogicalChannelNumber, 
+                   call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_dataTypeALCombinationNotSupported:
+      OOTRACEINFO4("Open logical channel %d rejected - "
+                   "dataTypeALCombinationNotSupported(%s, %s)\n", 
+                   olcReject->forwardLogicalChannelNumber, 
+                   call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_multicastChannelNotAllowed:
+       OOTRACEINFO4("Open logical channel %d rejected - "
+                    "multicastChannelNotAllowed (%s, %s)\n", 
+                    olcReject->forwardLogicalChannelNumber, 
+                    call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_insufficientBandwidth:
+      OOTRACEINFO4("Open logical channel %d rejected - insufficientBandwidth"
+                   "(%s, %s)\n", olcReject->forwardLogicalChannelNumber, 
+                   call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_separateStackEstablishmentFailed:
+      OOTRACEINFO4("Open logical channel %d rejected - "
+                    "separateStackEstablishmentFailed (%s, %s)\n", 
+                    olcReject->forwardLogicalChannelNumber, 
+                    call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_invalidSessionID:
+      OOTRACEINFO4("Open logical channel %d rejected - "
+                    "invalidSessionID (%s, %s)\n", 
+                    olcReject->forwardLogicalChannelNumber, 
+                    call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_masterSlaveConflict:
+      OOTRACEINFO4("Open logical channel %d rejected - "
+                    "invalidSessionID (%s, %s)\n", 
+                    olcReject->forwardLogicalChannelNumber, 
+                    call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_waitForCommunicationMode:
+      OOTRACEINFO4("Open logical channel %d rejected - "
+                    "waitForCommunicationMode (%s, %s)\n", 
+                    olcReject->forwardLogicalChannelNumber, 
+                    call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_invalidDependentChannel:
+      OOTRACEINFO4("Open logical channel %d rejected - "
+                    "invalidDependentChannel (%s, %s)\n", 
+                    olcReject->forwardLogicalChannelNumber, 
+                    call->callType, call->callToken);
+      break;
+   case T_H245OpenLogicalChannelReject_cause_replacementForRejected:
+      OOTRACEINFO4("Open logical channel %d rejected - "
+                    "replacementForRejected (%s, %s)\n", 
+                    olcReject->forwardLogicalChannelNumber, 
+                    call->callType, call->callToken);
+      break;
+   default:
+      OOTRACEERR4("Error: OpenLogicalChannel %d rejected - "
+                  "invalid cause(%s, %s)\n",
+                   olcReject->forwardLogicalChannelNumber, 
+                    call->callType, call->callToken);
+   }
+   if(call->callState < OO_CALL_CLEAR)
+   {
+      call->callState = OO_CALL_CLEAR;
+      call->callEndReason = OO_REASON_LOCAL_CLEARED;
+   }
+   return OO_OK;
+}
+
+/**
+ * Currently only disconnect end session command is supported.
+ **/
+int ooSendEndSessionCommand(OOH323CallData *call)
+{
+   int ret;
+   H245CommandMessage * command;
+   OOCTXT *pctxt;
+   H245Message *ph245msg=NULL;
+   ret = ooCreateH245Message(&ph245msg, 
+                      T_H245MultimediaSystemControlMessage_command);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error: H245 message creation failed for - End Session "
+                  "Command (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOEndSessionCommand;
+
+   command = ph245msg->h245Msg.u.command;
+   pctxt = &gH323ep.msgctxt;
+   memset(command, 0, sizeof(H245CommandMessage));
+   command->t = T_H245CommandMessage_endSessionCommand;
+   command->u.endSessionCommand = (H245EndSessionCommand*) ASN1MALLOC(pctxt,
+                                  sizeof(H245EndSessionCommand));
+   memset(command->u.endSessionCommand, 0, sizeof(H245EndSessionCommand));
+   command->u.endSessionCommand->t = T_H245EndSessionCommand_disconnect;
+   OOTRACEDBGA3("Built EndSession Command (%s, %s)\n", call->callType,
+                call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue EndSession message to outbound "
+                  "queue.(%s, %s)\n", call->callType, call->callToken);
+   }
+   ooFreeH245Message(call, ph245msg);
+   return ret;
+}
+
+
+int ooHandleH245Command(OOH323CallData *call, 
+                        H245CommandMessage *command)
+{
+   ASN1UINT i;
+   DListNode *pNode = NULL;
+   OOTimer *pTimer = NULL;
+   OOTRACEDBGC3("Handling H.245 command message. (%s, %s)\n", call->callType,
+                 call->callToken);
+   switch(command->t)
+   {
+      case T_H245CommandMessage_endSessionCommand:
+         OOTRACEINFO3("Received EndSession command (%s, %s)\n", 
+                       call->callType, call->callToken);
+         if(call->h245SessionState == OO_H245SESSION_ENDSENT)
+         {
+            /* Disable Session timer */
+            for(i = 0; i<call->timerList.count; i++)
+            {
+               pNode = dListFindByIndex(&call->timerList, i);
+               pTimer = (OOTimer*)pNode->data;
+               if(((ooTimerCallback*)pTimer->cbData)->timerType & 
+                                                            OO_SESSION_TIMER)
+               {
+                  ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                  ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                  OOTRACEDBGC3("Deleted Session Timer. (%s, %s)\n", 
+                                call->callType, call->callToken);
+                  break;
+               }
+            }
+            ooCloseH245Connection(call);
+         }
+         else{
+
+            call->h245SessionState = OO_H245SESSION_ENDRECVD;
+#if 0
+            if(call->callState < OO_CALL_CLEAR)
+               call->callState = OO_CALL_CLEAR;
+#else 
+            if(call->logicalChans)
+            {
+               OOTRACEINFO3("In response to received EndSessionCommand - "
+                            "Clearing all logical channels. (%s, %s)\n", 
+                            call->callType, call->callToken);
+               ooClearAllLogicalChannels(call);
+            }
+            ooSendEndSessionCommand(call);
+#endif
+         }
+            
+            
+         break;
+      case T_H245CommandMessage_sendTerminalCapabilitySet:
+         OOTRACEWARN3("Warning: Received command Send terminal capability set "
+                      "- Not handled (%s, %s)\n", call->callType, 
+                      call->callToken);
+         break;
+      case T_H245CommandMessage_flowControlCommand:
+         OOTRACEWARN3("Warning: Flow control command received - Not handled "
+                      "(%s, %s)\n", call->callType, call->callToken);
+         break;
+      default:
+         OOTRACEWARN3("Warning: Unhandled H245 command message received "
+                      "(%s, %s)\n", call->callType, call->callToken);
+   }
+   OOTRACEDBGC3("Handling H.245 command message done. (%s, %s)\n", 
+                 call->callType, call->callToken);   
+   return OO_OK;
+}
+
+
+int ooOnReceivedTerminalCapabilitySetAck(OOH323CallData* call)
+{
+   call->localTermCapState = OO_LocalTermCapSetAckRecvd;
+   if(call->remoteTermCapState != OO_RemoteTermCapSetAckSent)
+      return OO_OK;
+   
+   if(call->masterSlaveState == OO_MasterSlave_Master ||
+       call->masterSlaveState == OO_MasterSlave_Slave)
+   {
+      if(gH323ep.h323Callbacks.openLogicalChannels)
+         gH323ep.h323Callbacks.openLogicalChannels(call);
+      else{
+         if(!call->logicalChans)
+            ooOpenLogicalChannels(call);
+      }
+#if 0
+      if(!call->logicalChans){
+         if(!gH323ep.h323Callbacks.openLogicalChannels)
+            ooOpenLogicalChannels(call);
+         else
+            gH323ep.h323Callbacks.openLogicalChannels(call);
+      }
+#endif
+   }
+      
+   return OO_OK;
+}
+
+int ooCloseAllLogicalChannels(OOH323CallData *call)
+{
+   ooLogicalChannel *temp;
+
+   temp = call->logicalChans;
+   while(temp)
+   {
+      if(temp->state == OO_LOGICALCHAN_ESTABLISHED)
+      {
+         /* Sending closelogicalchannel only for outgoing channels*/
+         if(!strcmp(temp->dir, "transmit"))
+         {
+            ooSendCloseLogicalChannel(call, temp);
+         }
+         else{
+            ooSendRequestCloseLogicalChannel(call, temp);
+         }
+      }
+      temp = temp->next;
+   }
+   return OO_OK;
+}
+
+int ooSendCloseLogicalChannel(OOH323CallData *call, ooLogicalChannel *logicalChan)
+{
+   int ret = OO_OK, error=0;
+   H245Message *ph245msg = NULL;
+   OOCTXT *pctxt;
+   H245RequestMessage *request;
+   H245CloseLogicalChannel* clc;
+   
+   ret = ooCreateH245Message(&ph245msg, 
+                             T_H245MultimediaSystemControlMessage_request);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR:Failed to create H245 message for closeLogicalChannel"
+                  " message (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOCloseLogicalChannel;
+   ph245msg->logicalChannelNo = logicalChan->channelNo;
+   pctxt = &gH323ep.msgctxt;
+   request = ph245msg->h245Msg.u.request;
+
+   request->t = T_H245RequestMessage_closeLogicalChannel;
+   request->u.closeLogicalChannel = (H245CloseLogicalChannel*)ASN1MALLOC(pctxt,
+                                     sizeof(H245CloseLogicalChannel));
+   if(!request->u.closeLogicalChannel)
+   {
+      OOTRACEERR3("ERROR:Memory allocation for CloseLogicalChannel failed "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   clc = request->u.closeLogicalChannel;
+   memset(clc, 0, sizeof(H245CloseLogicalChannel));
+
+   clc->forwardLogicalChannelNumber = logicalChan->channelNo;
+   clc->source.t = T_H245CloseLogicalChannel_source_lcse;
+   clc->m.reasonPresent = 1;
+   clc->reason.t = T_H245CloseLogicalChannel_reason_unknown;
+
+   OOTRACEDBGA4("Built close logical channel for %d (%s, %s)\n", 
+                 logicalChan->channelNo, call->callType, call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+     OOTRACEERR3("Error:Failed to enqueue CloseLogicalChannel to outbound queue.(%s, %s)\n", call->callType,
+                 call->callToken);
+     error++;
+   }
+   ooFreeH245Message(call, ph245msg);
+   
+   /* Stop the media transmission */
+   OOTRACEINFO4("Closing logical channel %d (%s, %s)\n", 
+                clc->forwardLogicalChannelNumber, call->callType, 
+                call->callToken);
+   ret = ooClearLogicalChannel(call, clc->forwardLogicalChannelNumber);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR4("ERROR:Failed to close logical channel %d (%s, %s)\n",
+         clc->forwardLogicalChannelNumber, call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   if(error) return OO_FAILED;
+   return ret;
+}
+
+/*TODO: Need to pass reason as a parameter */
+int ooSendRequestCloseLogicalChannel(OOH323CallData *call, 
+                                     ooLogicalChannel *logicalChan)
+{
+   int ret = OO_OK;
+   H245Message *ph245msg = NULL;
+   OOCTXT *pctxt;
+   H245RequestMessage *request;
+   H245RequestChannelClose *rclc;
+
+   ret = ooCreateH245Message(&ph245msg, 
+                             T_H245MultimediaSystemControlMessage_request);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR:Failed to create H245 message for "
+                  "requestCloseLogicalChannel message (%s, %s)\n", 
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OORequestChannelClose;
+   ph245msg->logicalChannelNo = logicalChan->channelNo;
+   pctxt = &gH323ep.msgctxt;
+   request = ph245msg->h245Msg.u.request;
+
+   request->t = T_H245RequestMessage_requestChannelClose;
+   request->u.requestChannelClose = (H245RequestChannelClose*)ASN1MALLOC(pctxt,
+                                     sizeof(H245RequestChannelClose));
+   if(!request->u.requestChannelClose)
+   {
+      OOTRACEERR3("ERROR:Memory allocation for RequestCloseLogicalChannel "
+                  " failed (%s, %s)\n", call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+
+   rclc = request->u.requestChannelClose;
+   memset(rclc, 0, sizeof(H245RequestChannelClose));
+   rclc->forwardLogicalChannelNumber = logicalChan->channelNo;
+   
+   rclc->m.reasonPresent = 1;
+   rclc->reason.t = T_H245RequestChannelClose_reason_unknown;
+
+   OOTRACEDBGA4("Built RequestCloseChannel for %d (%s, %s)\n", 
+                 logicalChan->channelNo, call->callType, call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+     OOTRACEERR3("Error:Failed to enqueue the RequestCloseChannel to outbound"
+                 " queue (%s, %s)\n", call->callType,
+                 call->callToken);
+   }
+   ooFreeH245Message(call, ph245msg);
+
+   return ret;
+}
+
+int ooSendRequestChannelCloseRelease(OOH323CallData *call, int channelNum)
+{
+   int ret = OO_OK;
+   H245Message *ph245msg = NULL;
+   OOCTXT *pctxt;
+   H245IndicationMessage *indication;
+
+   ret = ooCreateH245Message(&ph245msg, 
+                             T_H245MultimediaSystemControlMessage_indication);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR:Failed to create H245 message for "
+                  "RequestChannelCloseRelease message (%s, %s)\n", 
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OORequestChannelCloseRelease;
+   ph245msg->logicalChannelNo = channelNum;
+   pctxt = &gH323ep.msgctxt;
+   indication = ph245msg->h245Msg.u.indication;
+   indication->t = T_H245IndicationMessage_requestChannelCloseRelease;
+   indication->u.requestChannelCloseRelease = (H245RequestChannelCloseRelease*)
+                     ASN1MALLOC(pctxt, sizeof(H245RequestChannelCloseRelease));
+   if(!indication->u.requestChannelCloseRelease)
+   {
+      OOTRACEERR3("Error:Failed to allocate memory for "
+                  "RequestChannelCloseRelease message. (%s, %s)\n", 
+                   call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+   }
+
+   indication->u.requestChannelCloseRelease->forwardLogicalChannelNumber = 
+                                                                channelNum;
+
+   OOTRACEDBGA4("Built RequestChannelCloseRelease for %d (%s, %s)\n", 
+                channelNum, call->callType, call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+     OOTRACEERR3("Error:Failed to enqueue the RequestChannelCloseRelease to "
+                 "outbound queue (%s, %s)\n", call->callType, call->callToken);
+   }
+   ooFreeH245Message(call, ph245msg);
+
+   return ret;
+}
+
+
+   
+int ooOnReceivedRequestChannelClose(OOH323CallData *call, 
+                                    H245RequestChannelClose *rclc)
+{
+   int ret=0, error=0;
+   H245Message *ph245msg=NULL;
+   H245ResponseMessage *response = NULL;
+   OOCTXT *pctxt=NULL;
+   H245RequestChannelCloseAck *rclcAck;
+   ooLogicalChannel * lChannel=NULL;
+   /* Send Ack: TODO: Need to send reject, if doesn't exist
+   */
+   lChannel = ooFindLogicalChannelByLogicalChannelNo(call, 
+                                        rclc->forwardLogicalChannelNumber);
+   if(!lChannel)
+   {
+      OOTRACEERR4("ERROR:Channel %d requested to be closed not found "
+                  "(%s, %s)\n", rclc->forwardLogicalChannelNumber,
+                  call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   else{
+      if(strcmp(lChannel->dir, "transmit"))
+      {
+         OOTRACEERR4("ERROR:Channel %d requested to be closed, Not a forward "
+                     "channel (%s, %s)\n", rclc->forwardLogicalChannelNumber,
+                     call->callType, call->callToken);
+         return OO_FAILED;
+      }
+   }
+   ret = ooCreateH245Message(&ph245msg, 
+                             T_H245MultimediaSystemControlMessage_response);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR:Memory allocation for RequestChannelCloseAck message "
+                  "failed (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   pctxt = &gH323ep.msgctxt;
+   ph245msg->msgType = OORequestChannelCloseAck;
+   ph245msg->logicalChannelNo = rclc->forwardLogicalChannelNumber;
+   response = ph245msg->h245Msg.u.response;
+   response->t = T_H245ResponseMessage_requestChannelCloseAck;
+   response->u.requestChannelCloseAck = (H245RequestChannelCloseAck*)ASN1MALLOC
+                                   (pctxt, sizeof(H245RequestChannelCloseAck));
+   if(!response->u.requestChannelCloseAck)
+   {
+      OOTRACEERR3("ERROR:Failed to allocate memory for RequestChannelCloseAck "
+                  "message (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   rclcAck = response->u.requestChannelCloseAck;
+   memset(rclcAck, 0, sizeof(H245RequestChannelCloseAck));
+   rclcAck->forwardLogicalChannelNumber = rclc->forwardLogicalChannelNumber;
+
+   OOTRACEDBGA3("Built RequestCloseChannelAck message (%s, %s)\n", 
+                 call->callType, call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue RequestCloseChannelAck to outbound queue. (%s, %s)\n", call->callType,
+                  call->callToken);
+      error++;
+   }
+
+   ooFreeH245Message(call, ph245msg);
+   
+   /* Send Close Logical Channel*/
+   ret = ooSendCloseLogicalChannel(call, lChannel);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR:Failed to build CloseLgicalChannel message(%s, %s)\n",
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   if(error) return OO_FAILED;
+
+   return ret;
+}
+
+/*
+  We clear channel here. Ideally the remote endpoint should send 
+  CloseLogicalChannel and then the channel should be cleared. But there's no
+  timer for this and if remote endpoint misbehaves, the call will keep waiting
+  for CloseLogicalChannel and hence, wouldn't be cleared. In case when remote
+  endpoint sends CloseLogicalChannel, we call ooClearLogicalChannel again,
+  which simply returns OO_OK as channel was already cleared. Other option is
+  to start a timer for call cleanup and if call is not cleaned up within 
+  timeout, we clean call forcefully. Note, no such timer is defined in 
+  standards.
+*/
+int ooOnReceivedRequestChannelCloseAck
+                       (OOH323CallData *call, H245RequestChannelCloseAck *rccAck)
+{
+   int ret=OO_OK;
+   /* Remote endpoint is ok to close channel. So let's do it */
+   ret = ooClearLogicalChannel(call, rccAck->forwardLogicalChannelNumber);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR4("Error:Failed to clear logical channel %d. (%s, %s)\n", 
+                   rccAck->forwardLogicalChannelNumber, call->callType, 
+                   call->callToken);
+   }
+
+   return ret;
+}
+
+int ooOnReceivedRequestChannelCloseReject
+   (OOH323CallData *call, H245RequestChannelCloseReject *rccReject)
+{
+   int ret =0;
+   switch(rccReject->cause.t)
+   {
+   case T_H245RequestChannelCloseReject_cause_unspecified:
+      OOTRACEDBGA4("Remote endpoint has rejected request to close logical "
+                   "channel %d - cause unspecified. (%s, %s)\n", 
+                   rccReject->forwardLogicalChannelNumber, call->callType, 
+                   call->callToken);
+     break;
+   case T_H245RequestChannelCloseReject_cause_extElem1:
+      OOTRACEDBGA4("Remote endpoint has rejected request to close logical "
+                   "channel %d - cause propriatory. (%s, %s)\n", 
+                   rccReject->forwardLogicalChannelNumber, call->callType, 
+                   call->callToken);   
+      break;
+   default:
+      OOTRACEDBGA4("Remote endpoint has rejected request to close logical "
+                   "channel %d - cause INVALID. (%s, %s)\n", 
+                   rccReject->forwardLogicalChannelNumber, call->callType, 
+                   call->callToken);
+   }
+   OOTRACEDBGA4("Clearing logical channel %d. (%s, %s)\n", 
+                 rccReject->forwardLogicalChannelNumber, call->callType, 
+                 call->callToken);
+   ret = ooClearLogicalChannel(call, rccReject->forwardLogicalChannelNumber);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR4("Error: failed to clear logical channel %d.(%s, %s)\n", 
+                   rccReject->forwardLogicalChannelNumber, call->callType, 
+                   call->callToken);
+   }
+   return ret;
+}
+
+/****/
+int ooOnReceivedCloseLogicalChannel(OOH323CallData *call, 
+                                    H245CloseLogicalChannel* clc)
+{
+   int ret=0;
+   H245Message *ph245msg = NULL;
+   OOCTXT *pctxt = NULL;
+   H245CloseLogicalChannelAck * clcAck;
+   H245ResponseMessage *response;
+   
+   OOTRACEINFO4("Closing logical channel number %d (%s, %s)\n",
+      clc->forwardLogicalChannelNumber, call->callType, call->callToken);
+   
+   ret = ooClearLogicalChannel(call, clc->forwardLogicalChannelNumber);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR4("ERROR:Failed to close logical channel %d (%s, %s)\n",
+         clc->forwardLogicalChannelNumber, call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   ret = ooCreateH245Message(&ph245msg, 
+                              T_H245MultimediaSystemControlMessage_response);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR:Failed to create H245 message for "
+                  "closeLogicalChannelAck (%s, %s)\n", call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   pctxt = &gH323ep.msgctxt;
+   ph245msg->msgType = OOCloseLogicalChannelAck;
+   ph245msg->logicalChannelNo = clc->forwardLogicalChannelNumber;
+   response = ph245msg->h245Msg.u.response;
+   response->t = T_H245ResponseMessage_closeLogicalChannelAck;
+   response->u.closeLogicalChannelAck = (H245CloseLogicalChannelAck*)
+                         ASN1MALLOC(pctxt, sizeof(H245CloseLogicalChannelAck));
+   clcAck = response->u.closeLogicalChannelAck;
+   if(!clcAck)
+   {
+      OOTRACEERR3("ERROR:Failed to allocate memory for closeLogicalChannelAck "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_OK;
+   }
+   memset(clcAck, 0, sizeof(H245CloseLogicalChannelAck));
+   clcAck->forwardLogicalChannelNumber = clc->forwardLogicalChannelNumber;
+
+   OOTRACEDBGA3("Built CloseLogicalChannelAck message (%s, %s)\n",
+                 call->callType, call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+     OOTRACEERR3("Error:Failed to enqueue CloseLogicalChannelAck message to "
+                 "outbound queue.(%s, %s)\n", call->callType, call->callToken);
+   }
+
+   ooFreeH245Message(call, ph245msg);
+   return ret;
+}
+
+int ooOnReceivedCloseChannelAck(OOH323CallData* call, 
+                                H245CloseLogicalChannelAck* clcAck)
+{
+   int ret = OO_OK;
+   return ret;
+}
+
+int ooHandleH245Message(OOH323CallData *call, H245Message * pmsg)
+{
+   ASN1UINT i;
+   DListNode *pNode = NULL;
+   OOTimer *pTimer = NULL;
+   H245Message *pH245 = (H245Message*)pmsg;
+   /* There are four major types of H.245 messages that can be received.
+      Request/Response/Command/Indication. Each one of them need to be 
+      handled separately.
+   */   
+   H245RequestMessage *request = NULL;
+   H245ResponseMessage *response = NULL;
+   H245CommandMessage *command = NULL;
+   H245IndicationMessage *indication = NULL;
+   
+   OOTRACEDBGC3("Handling H245 message. (%s, %s)\n", call->callType, 
+                 call->callToken);
+   
+   switch(pH245->h245Msg.t)
+   {
+      /* H.245 Request message is received */
+      case (T_H245MultimediaSystemControlMessage_request):
+         request = pH245->h245Msg.u.request;
+         switch(request->t)
+         {
+            case T_H245RequestMessage_terminalCapabilitySet:
+               /* If session isn't marked active yet, do it. possible in case of 
+                  tunneling */
+               if(call->h245SessionState == OO_H245SESSION_IDLE)
+                  call->h245SessionState = OO_H245SESSION_ACTIVE; 
+
+               ooOnReceivedTerminalCapabilitySet(call, pH245);
+               if(call->localTermCapState == OO_LocalTermCapExchange_Idle)
+                  ooSendTermCapMsg(call);
+               break;
+            case T_H245RequestMessage_masterSlaveDetermination:
+               ooHandleMasterSlave(call, 
+                                     request->u.masterSlaveDetermination, 
+                                     OOMasterSlaveDetermination);
+               break;
+            case T_H245RequestMessage_openLogicalChannel:
+               ooHandleOpenLogicalChannel(call, 
+                                          request->u.openLogicalChannel);
+               break;
+            case T_H245RequestMessage_closeLogicalChannel:
+               OOTRACEINFO4("Received close logical Channel - %d (%s, %s)\n",
+                  request->u.closeLogicalChannel->forwardLogicalChannelNumber, 
+                  call->callType, call->callToken);
+               ooOnReceivedCloseLogicalChannel(call, 
+                                               request->u.closeLogicalChannel);
+               break;
+            case T_H245RequestMessage_requestChannelClose:
+               OOTRACEINFO4("Received RequestChannelClose - %d (%s, %s)\n",
+                  request->u.requestChannelClose->forwardLogicalChannelNumber, 
+                  call->callType, call->callToken);
+               ooOnReceivedRequestChannelClose(call, 
+                                               request->u.requestChannelClose);
+               break;
+            default:
+               ;
+         } /* End of Request Message */
+         break;
+      /* H.245 Response message is received */ 
+      case (T_H245MultimediaSystemControlMessage_response):
+         response = pH245->h245Msg.u.response;
+         switch(response->t)
+         {
+            case T_H245ResponseMessage_masterSlaveDeterminationAck:
+               /* Disable MSD timer */
+               for(i = 0; i<call->timerList.count; i++)
+               {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if(((ooTimerCallback*)pTimer->cbData)->timerType & OO_MSD_TIMER)
+                  {
+                     ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted MSD Timer. (%s, %s)\n", call->callType,
+                   call->callToken);
+                     break;
+                  }
+               }
+
+               ooHandleMasterSlave(call, 
+                                   response->u.masterSlaveDeterminationAck, 
+                                   OOMasterSlaveAck);
+               break;
+            case T_H245ResponseMessage_masterSlaveDeterminationReject:
+               /* Disable MSD timer */
+               for(i = 0; i<call->timerList.count; i++)
+               {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if(((ooTimerCallback*)pTimer->cbData)->timerType & OO_MSD_TIMER)
+                  {
+                     ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted MSD Timer. (%s, %s)\n", call->callType,
+                   call->callToken);
+                     break;
+                  }
+               }
+               ooHandleMasterSlaveReject(call, 
+                                  response->u.masterSlaveDeterminationReject);
+               break;
+            case T_H245ResponseMessage_terminalCapabilitySetAck:
+               /* Disable TCS timer */
+               for(i = 0; i<call->timerList.count; i++)
+               {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if(((ooTimerCallback*)pTimer->cbData)->timerType & OO_TCS_TIMER)
+                  {
+                     ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted TCS Timer. (%s, %s)\n", call->callType,
+                        call->callToken);
+                     break;
+                  }
+               }
+               ooOnReceivedTerminalCapabilitySetAck(call);
+               break;
+            case T_H245ResponseMessage_terminalCapabilitySetReject:
+               OOTRACEINFO3("TerminalCapabilitySetReject message received."
+                            " (%s, %s)\n", call->callType, call->callToken);
+               if(response->u.terminalCapabilitySetReject->sequenceNumber != 
+                  call->localTermCapSeqNo)
+               {
+                  OOTRACEINFO5("Ignoring TCSReject with mismatched seqno %d "
+                              "(local - %d). (%s, %s)\n", 
+                          response->u.terminalCapabilitySetReject->sequenceNumber,
+                        call->localTermCapSeqNo, call->callType, call->callToken);
+                  break;
+               }
+               /* Disable TCS timer */
+               for(i = 0; i<call->timerList.count; i++)
+               {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if(((ooTimerCallback*)pTimer->cbData)->timerType & OO_TCS_TIMER)
+                  {
+                     ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted TCS Timer. (%s, %s)\n", call->callType,
+                        call->callToken);
+                     break;
+                  }
+               }
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callState = OO_CALL_CLEAR;
+                  call->callEndReason = OO_REASON_NOCOMMON_CAPABILITIES;
+               }
+               break;
+            case T_H245ResponseMessage_openLogicalChannelAck:
+               for(i = 0; i<call->timerList.count; i++)
+               {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_OLC_TIMER)                                            && 
+                      ((ooTimerCallback*)pTimer->cbData)->channelNumber == 
+                   response->u.openLogicalChannelAck->forwardLogicalChannelNumber)
+                  {
+
+                     memFreePtr(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted OpenLogicalChannel Timer. (%s, %s)\n", 
+                                   call->callType, call->callToken);
+                     break;
+                  }
+               }
+               ooOnReceivedOpenLogicalChannelAck(call, 
+                                              response->u.openLogicalChannelAck);
+               break;
+            case T_H245ResponseMessage_openLogicalChannelReject:
+               OOTRACEINFO3("Open Logical Channel Reject received (%s, %s)\n",
+                             call->callType, call->callToken);
+               for(i = 0; i<call->timerList.count; i++)
+               {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_OLC_TIMER)                                            && 
+                      ((ooTimerCallback*)pTimer->cbData)->channelNumber == 
+                   response->u.openLogicalChannelAck->forwardLogicalChannelNumber)
+                  {
+
+                     ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted OpenLogicalChannel Timer. (%s, %s)\n", 
+                                   call->callType, call->callToken);
+                     break;
+                  }
+               }
+               ooOnReceivedOpenLogicalChannelRejected(call, 
+                                        response->u.openLogicalChannelReject);
+               break;
+            case T_H245ResponseMessage_closeLogicalChannelAck:
+               OOTRACEINFO4("CloseLogicalChannelAck received for %d (%s, %s)\n",
+                  response->u.closeLogicalChannelAck->forwardLogicalChannelNumber,
+                  call->callType, call->callToken);
+               for(i = 0; i<call->timerList.count; i++)
+               {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_CLC_TIMER)                                            && 
+                      ((ooTimerCallback*)pTimer->cbData)->channelNumber == 
+                  response->u.closeLogicalChannelAck->forwardLogicalChannelNumber)
+                  {
+
+                     ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted CloseLogicalChannel Timer. (%s, %s)\n",
+                                   call->callType, call->callToken);
+                     break;
+                  }
+               }
+               ooOnReceivedCloseChannelAck(call, 
+                                           response->u.closeLogicalChannelAck);
+               break;
+            case T_H245ResponseMessage_requestChannelCloseAck:
+                OOTRACEINFO4("RequestChannelCloseAck received - %d (%s, %s)\n",
+                  response->u.requestChannelCloseAck->forwardLogicalChannelNumber,
+                  call->callType, call->callToken);
+                for(i = 0; i<call->timerList.count; i++)
+                {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_RCC_TIMER)                                            && 
+                      ((ooTimerCallback*)pTimer->cbData)->channelNumber == 
+                  response->u.requestChannelCloseAck->forwardLogicalChannelNumber)
+                  {
+
+                     ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted RequestChannelClose Timer. (%s, %s)\n",
+                                   call->callType, call->callToken);
+                     break;
+                  }
+                }
+                ooOnReceivedRequestChannelCloseAck(call, 
+                                             response->u.requestChannelCloseAck);
+                break;
+            case T_H245ResponseMessage_requestChannelCloseReject:
+               OOTRACEINFO4("RequestChannelCloseReject received - %d (%s, %s)\n",
+               response->u.requestChannelCloseReject->forwardLogicalChannelNumber,
+                 call->callType, call->callToken);
+                for(i = 0; i<call->timerList.count; i++)
+                {
+                  pNode = dListFindByIndex(&call->timerList, i);
+                  pTimer = (OOTimer*)pNode->data;
+                  if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_RCC_TIMER) && 
+                      ((ooTimerCallback*)pTimer->cbData)->channelNumber == 
+                      response->u.requestChannelCloseReject->forwardLogicalChannelNumber)
+                  {
+
+                     ASN1MEMFREEPTR(call->pctxt, pTimer->cbData);
+                     ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+                     OOTRACEDBGC3("Deleted RequestChannelClose Timer. (%s, %s)\n",
+                                   call->callType, call->callToken);
+                     break;
+                  }
+               }
+               ooOnReceivedRequestChannelCloseReject(call, 
+                                           response->u.requestChannelCloseReject);
+               break;
+            default:
+               ;
+         }
+         break;
+      /* H.245 command message is received */
+      case (T_H245MultimediaSystemControlMessage_command):
+         command = pH245->h245Msg.u.command;
+         ooHandleH245Command(call, command);
+         break;
+      /* H.245 Indication message received */
+      case (T_H245MultimediaSystemControlMessage_indication):
+         indication = pH245->h245Msg.u.indication;
+         switch(indication->t)
+         {
+            case T_H245IndicationMessage_userInput:
+               ooOnReceivedUserInputIndication(call, indication->u.userInput);
+               break;
+            default:
+               OOTRACEWARN3("Unhandled indication message received.(%s, %s)\n",
+                             call->callType, call->callToken);
+         }
+         break;
+      default:
+        ;
+   }
+   OOTRACEDBGC3("Finished handling H245 message. (%s, %s)\n", 
+                 call->callType, call->callToken);
+   return OO_OK;
+}
+
+
+int ooOnReceivedUserInputIndication
+   (OOH323CallData *call, H245UserInputIndication *indication)
+{
+   if((indication->t == T_H245UserInputIndication_alphanumeric) && 
+      (call->dtmfmode & OO_CAP_DTMF_H245_alphanumeric))
+   {
+      if(gH323ep.h323Callbacks.onReceivedDTMF)
+         gH323ep.h323Callbacks.onReceivedDTMF(call,indication->u.alphanumeric);
+   }
+   else if((indication->t == T_H245UserInputIndication_signal) && 
+           (call->dtmfmode & OO_CAP_DTMF_H245_signal)) {
+      if(gH323ep.h323Callbacks.onReceivedDTMF)
+         gH323ep.h323Callbacks.onReceivedDTMF(call, 
+                                             indication->u.signal->signalType);
+   }
+   else {
+      OOTRACEINFO3("Unsupported userInput message type received - ignoring."
+                   "(%s, %s)\n", call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooOnReceivedTerminalCapabilitySet(OOH323CallData *call, H245Message *pmsg)
+{
+   int ret = 0,k;
+   H245TerminalCapabilitySet *tcs=NULL;
+   DListNode *pNode=NULL;
+   H245CapabilityTableEntry *capEntry = NULL;
+
+   tcs =  pmsg->h245Msg.u.request->u.terminalCapabilitySet;
+   if(call->remoteTermCapSeqNo >= tcs->sequenceNumber)
+   {
+      OOTRACEINFO4("Rejecting TermCapSet message with SeqNo %d, as already "
+                   "acknowledged message with this SeqNo (%s, %s)\n", 
+                   call->remoteTermCapSeqNo, call->callType, call->callToken);
+      ooSendTerminalCapabilitySetReject(call, tcs->sequenceNumber, 
+                         T_H245TerminalCapabilitySetReject_cause_unspecified);
+      return OO_OK;
+   }
+  
+   if(!tcs->m.capabilityTablePresent)
+   {
+      // OOTRACEWARN3("Warn:Ignoring TCS as no capability table present(%s, %s)\n",
+      OOTRACEWARN3("Empty TCS found.  Pausing call...(%s, %s)\n",
+                    call->callType, call->callToken);
+      call->h245SessionState = OO_H245SESSION_PAUSED;
+      //ooSendTerminalCapabilitySetReject(call, tcs->sequenceNumber, 
+      //                   T_H245TerminalCapabilitySetReject_cause_unspecified);
+      //return OO_OK;
+   }
+   call->remoteTermCapSeqNo = tcs->sequenceNumber;
+
+   if(tcs->m.capabilityTablePresent) {
+      for(k=0; k<(int)tcs->capabilityTable.count; k++)
+      {
+         pNode = dListFindByIndex(&tcs->capabilityTable, k);
+         if(pNode)
+         {
+            OOTRACEDBGC4("Processing CapabilityTable Entry %d (%s, %s)\n", 
+                          k, call->callType, call->callToken);
+            capEntry = (H245CapabilityTableEntry*) pNode->data;
+            if(capEntry->m.capabilityPresent){
+               ret =  ooAddRemoteCapability(call, &capEntry->capability);
+               if(ret != OO_OK)
+               {
+                  OOTRACEERR4("Error:Failed to process remote capability in "
+                              "capability table at index %d. (%s, %s)\n", 
+                               k, call->callType, call->callToken);
+               }
+               ooCapabilityUpdateJointCapabilities(call, &capEntry->capability);
+            }
+         }
+         pNode = NULL;
+         capEntry=NULL;
+      }
+   }
+
+   
+   /* Update remoteTermCapSetState */
+   call->remoteTermCapState = OO_RemoteTermCapSetRecvd;
+
+   ooH245AcknowledgeTerminalCapabilitySet(call);   
+
+   /* If we haven't yet send TCS then send it now */
+   if(call->localTermCapState == OO_LocalTermCapExchange_Idle)
+   {
+      ret = ooSendTermCapMsg(call);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n",
+                      call->callType, call->callToken);
+         return ret;
+      }
+   }
+
+   if(call->remoteTermCapState != OO_RemoteTermCapSetAckSent ||
+      call->localTermCapState  != OO_LocalTermCapSetAckRecvd)
+      return OO_OK;
+
+   /* Check MasterSlave procedure has finished */
+   if(call->masterSlaveState != OO_MasterSlave_Master &&
+      call->masterSlaveState != OO_MasterSlave_Slave)
+      return OO_OK;
+
+   /* As both MasterSlave and TerminalCapabilitySet procedures have finished,
+      OpenLogicalChannels */
+ 
+   if(gH323ep.h323Callbacks.openLogicalChannels)
+      gH323ep.h323Callbacks.openLogicalChannels(call);
+   else{
+      if(!call->logicalChans)
+         ooOpenLogicalChannels(call);
+   }
+#if 0
+   if(!call->logicalChans){
+      if(!gH323ep.h323Callbacks.openLogicalChannels)
+         ret = ooOpenLogicalChannels(call);
+      else
+         gH323ep.h323Callbacks.openLogicalChannels(call);
+   }
+#endif
+   return OO_OK;
+}
+
+int ooSendTerminalCapabilitySetReject
+                        (OOH323CallData *call, int seqNo, ASN1UINT cause)
+{
+   H245Message *ph245msg=NULL;
+   H245ResponseMessage * response=NULL;
+   OOCTXT *pctxt=NULL;
+   int ret = ooCreateH245Message(&ph245msg, 
+                      T_H245MultimediaSystemControlMessage_response);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR1("ERROR:H245 message creation failed for - "
+                           "TerminalCapabilitySetReject\n");
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOTerminalCapabilitySetReject;
+   response = ph245msg->h245Msg.u.response;
+   memset(response, 0, sizeof(H245ResponseMessage));
+   pctxt = &gH323ep.msgctxt;
+   response->t = T_H245ResponseMessage_terminalCapabilitySetReject;
+   
+   response->u.terminalCapabilitySetReject = (H245TerminalCapabilitySetReject*)
+                   ASN1MALLOC(pctxt, sizeof(H245TerminalCapabilitySetReject));
+
+   memset(response->u.terminalCapabilitySetReject, 0, 
+                                 sizeof(H245TerminalCapabilitySetReject));
+   response->u.terminalCapabilitySetReject->sequenceNumber = seqNo;
+   response->u.terminalCapabilitySetReject->cause.t = cause;
+
+   OOTRACEDBGA3("Built TerminalCapabilitySetReject (%s, %s)\n", 
+                 call->callType, call->callToken);
+ 
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+     OOTRACEERR3("Error:Failed to enqueue TCSReject to outbound queue. "
+                 "(%s, %s)\n", call->callType, call->callToken);
+   }
+   else
+      call->remoteTermCapState = OO_RemoteTermCapExchange_Idle;
+
+   ooFreeH245Message(call, ph245msg);
+   return ret;
+}
+
+int ooH245AcknowledgeTerminalCapabilitySet(OOH323CallData *call)
+{
+   H245Message *ph245msg=NULL;
+   H245ResponseMessage * response=NULL;
+   OOCTXT *pctxt=NULL;
+   int ret = ooCreateH245Message(&ph245msg, 
+                      T_H245MultimediaSystemControlMessage_response);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR1("ERROR:H245 message creation failed for - "
+                           "TerminalCapability Set Ack\n");
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOTerminalCapabilitySetAck;
+   response = ph245msg->h245Msg.u.response;
+   memset(response, 0, sizeof(H245ResponseMessage));
+   pctxt = &gH323ep.msgctxt;
+   response->t = T_H245ResponseMessage_terminalCapabilitySetAck;
+   
+   response->u.terminalCapabilitySetAck = (H245TerminalCapabilitySetAck*)
+                   ASN1MALLOC(pctxt, sizeof(H245TerminalCapabilitySetAck));
+
+   memset(response->u.terminalCapabilitySetAck, 0, 
+                                 sizeof(H245TerminalCapabilitySetAck));
+   response->u.terminalCapabilitySetAck->sequenceNumber = call->remoteTermCapSeqNo;
+
+   OOTRACEDBGA3("Built TerminalCapabilitySet Ack (%s, %s)\n", 
+                 call->callType, call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+
+   if(ret != OO_OK)
+   {
+     OOTRACEERR3("Error:Failed to enqueue TCSAck to outbound queue. (%s, %s)\n", call->callType, call->callToken);
+   }
+   else
+      call->remoteTermCapState = OO_RemoteTermCapSetAckSent;
+
+   ooFreeH245Message(call, ph245msg);
+   return ret;
+}
+
+
+int ooSendTerminalCapabilitySetRelease(OOH323CallData * call)
+{
+   int ret=0;
+   H245IndicationMessage* indication=NULL;
+   H245Message *ph245msg=NULL;
+   OOCTXT *pctxt=&gH323ep.msgctxt;
+
+   ret = ooCreateH245Message
+      (&ph245msg, T_H245MultimediaSystemControlMessage_indication);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3("Error:H245 message creation failed for - Terminal"
+                  "CapabilitySetRelease (%s, %s)\n",call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOTerminalCapabilitySetRelease;
+   indication = ph245msg->h245Msg.u.indication;
+
+   indication->t = T_H245IndicationMessage_terminalCapabilitySetRelease;
+
+   indication->u.terminalCapabilitySetRelease = 
+      (H245TerminalCapabilitySetRelease*)
+      memAlloc (pctxt, sizeof(H245TerminalCapabilitySetRelease));
+
+   if(!indication->u.terminalCapabilitySetRelease)
+   {
+      OOTRACEERR3("Error: Failed to allocate memory for TCSRelease message."
+                  " (%s, %s)\n", call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   OOTRACEDBGA3 ("Built TerminalCapabilitySetRelease (%s, %s)\n", 
+                 call->callType, call->callToken);
+
+   ret = ooSendH245Msg (call, ph245msg);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3 
+         ("Error:Failed to enqueue TerminalCapabilitySetRelease "
+         "message to outbound queue.(%s, %s)\n", call->callType, 
+         call->callToken);
+   }
+   
+   ooFreeH245Message (call, ph245msg);
+   return ret;
+}
+
+
+int ooSendH245UserInputIndication_alphanumeric
+   (OOH323CallData *call, const char *data)
+{
+   int ret=0;
+   H245IndicationMessage* indication=NULL;
+   H245Message *ph245msg=NULL;
+   OOCTXT *pctxt=&gH323ep.msgctxt;
+
+   ret = ooCreateH245Message
+      (&ph245msg, T_H245MultimediaSystemControlMessage_indication);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3("Error:H245 message creation failed for - H245UserInput"
+                  "Indication_alphanumeric (%s, %s)\n",call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOUserInputIndication;
+   indication = ph245msg->h245Msg.u.indication;
+
+   indication->t = T_H245IndicationMessage_userInput;
+   indication->u.userInput = 
+      (H245UserInputIndication*)
+      memAllocZ (pctxt, sizeof(H245UserInputIndication));
+
+   if(!indication->u.userInput)
+   {
+      OOTRACEERR3("Error: Memory - ooH245UserInputIndication_alphanumeric - "
+                  " userInput (%s, %s)\n", call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   indication->u.userInput->t = T_H245UserInputIndication_alphanumeric;
+   indication->u.userInput->u.alphanumeric = (ASN1GeneralString)
+                                              memAlloc(pctxt, strlen(data)+1);
+   if(!indication->u.userInput->u.alphanumeric)
+   {
+      OOTRACEERR3("Error: Memory - ooH245UserInputIndication-alphanumeric - "
+                  "alphanumeric (%s, %s).\n", call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   strcpy((char*)indication->u.userInput->u.alphanumeric, data);
+   OOTRACEDBGA3 ("Built UserInputIndication_alphanumeric (%s, %s)\n", 
+                 call->callType, call->callToken);
+
+   ret = ooSendH245Msg (call, ph245msg);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3 
+         ("Error:Failed to enqueue UserInputIndication_alphanumeric "
+          "message to outbound queue.(%s, %s)\n", call->callType, 
+          call->callToken);
+   }
+   
+   ooFreeH245Message (call, ph245msg);
+   return ret;
+}
+
+int ooSendH245UserInputIndication_signal
+   (OOH323CallData *call, const char *data)
+{
+   int ret=0;
+   H245IndicationMessage* indication=NULL;
+   H245Message *ph245msg=NULL;
+   OOCTXT *pctxt=&gH323ep.msgctxt;
+
+   ret = ooCreateH245Message
+      (&ph245msg, T_H245MultimediaSystemControlMessage_indication);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3("Error:H245 message creation failed for - H245UserInput"
+                  "Indication_signal (%s, %s)\n",call->callType, 
+                  call->callToken);
+      return OO_FAILED;
+   }
+   ph245msg->msgType = OOUserInputIndication;
+   indication = ph245msg->h245Msg.u.indication;
+
+   indication->t = T_H245IndicationMessage_userInput;
+   indication->u.userInput = 
+      (H245UserInputIndication*)
+      memAllocZ (pctxt, sizeof(H245UserInputIndication));
+
+   if(!indication->u.userInput)
+   {
+      OOTRACEERR3("Error: Memory - ooH245UserInputIndication_signal - "
+                  " userInput (%s, %s)\n", call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   indication->u.userInput->t = T_H245UserInputIndication_signal;
+   indication->u.userInput->u.signal = (H245UserInputIndication_signal*)
+                      memAllocZ(pctxt, sizeof(H245UserInputIndication_signal));
+   indication->u.userInput->u.signal->signalType = (ASN1IA5String)
+                                              memAlloc(pctxt, strlen(data)+1);
+   if(!indication->u.userInput->u.signal ||
+      !indication->u.userInput->u.signal->signalType)
+   {
+      OOTRACEERR3("Error: Memory - ooH245UserInputIndication_signal - "
+                  "signal (%s, %s).\n", call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   strcpy((char*)indication->u.userInput->u.signal->signalType, data);
+   OOTRACEDBGA3 ("Built UserInputIndication_signal (%s, %s)\n", 
+                 call->callType, call->callToken);
+
+   ret = ooSendH245Msg (call, ph245msg);
+
+   if (ret != OO_OK) {
+      OOTRACEERR3 
+         ("Error:Failed to enqueue UserInputIndication_signal "
+          "message to outbound queue.(%s, %s)\n", call->callType, 
+          call->callToken);
+   }
+   
+   ooFreeH245Message (call, ph245msg);
+   return ret;
+}
+
+
+int ooOpenLogicalChannels(OOH323CallData *call)
+{
+   int ret=0;
+   OOTRACEINFO3("Opening logical channels (%s, %s)\n", call->callType, 
+                 call->callToken); 
+
+   /* Audio channels */
+   if(gH323ep.callMode == OO_CALLMODE_AUDIOCALL ||
+      gH323ep.callMode == OO_CALLMODE_AUDIOTX)
+   {
+      //if (!OO_TESTFLAG (call->flags, OO_M_AUDIOSESSION))
+      //{
+         ret = ooOpenLogicalChannel(call, OO_CAP_TYPE_AUDIO);
+         if(ret != OO_OK)
+         {
+            OOTRACEERR3("ERROR:Failed to open audio channels. Clearing call."
+                        "(%s, %s)\n", call->callType, call->callToken);
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_LOCAL_CLEARED;
+               call->callState = OO_CALL_CLEAR;
+            }
+            return ret;
+         }
+      // }
+   }
+   
+   if(gH323ep.callMode == OO_CALLMODE_VIDEOCALL)
+   {
+     /*      if (!OO_TESTFLAG (call->flags, OO_M_AUDIOSESSION))
+        {*/
+         ret = ooOpenLogicalChannel(call, OO_CAP_TYPE_AUDIO);
+         if(ret != OO_OK)
+         {
+            OOTRACEERR3("ERROR:Failed to open audio channel. Clearing call."
+                        "(%s, %s)\n", call->callType, call->callToken);
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_LOCAL_CLEARED;
+               call->callState = OO_CALL_CLEAR;
+            }
+            return ret;
+         }
+      //}
+      /*      if(!OO_TESTFLAG(call->flags, OO_M_VIDEOSESSION))
+      {*/
+         ret = ooOpenLogicalChannel(call, OO_CAP_TYPE_VIDEO);
+         if(ret != OO_OK)
+         {
+            OOTRACEERR3("ERROR:Failed to open video channel. Clearing call."
+                        "(%s, %s)\n", call->callType, call->callToken);
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_LOCAL_CLEARED;
+               call->callState = OO_CALL_CLEAR;
+            }
+            return ret;
+         }
+     //}
+   }
+   return OO_OK;
+}
+
+/* CapType indicates whether to Open Audio or Video channel */
+int ooOpenLogicalChannel(OOH323CallData *call, enum OOCapType capType )
+{
+   ooH323EpCapability *epCap=NULL;
+   int k=0;
+
+   /* Check whether local endpoint has audio capability */
+   if(gH323ep.myCaps == 0 && call->ourCaps == 0)
+   {
+      OOTRACEERR3("ERROR:Local endpoint does not have any audio capabilities"
+                  " (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   
+   /* Go through local endpoints capabilities sequentially, and find out the
+      first one which has a match in the remote endpoints receive capabilities.
+   */
+   OOTRACEINFO3("Looking for matching capabilities. (%s, %s)\n", 
+                 call->callType, call->callToken);
+   if(call->masterSlaveState == OO_MasterSlave_Master)
+   {
+      for(k=0; k<call->capPrefs.index; k++)
+      {
+         /*Search for audio caps only */
+         if(capType == OO_CAP_TYPE_AUDIO && 
+            call->capPrefs.order[k] > OO_CAP_VIDEO_BASE)
+            continue;
+         /* Search for video caps only */
+         if(capType == OO_CAP_TYPE_VIDEO && 
+            call->capPrefs.order[k] <= OO_CAP_VIDEO_BASE)
+            continue;
+
+         epCap = call->jointCaps;
+
+         while(epCap){
+            if(epCap->cap == call->capPrefs.order[k] && (epCap->dir & OOTX))
+               break;
+            epCap = epCap->next;
+         }
+         if(!epCap)
+         {
+            OOTRACEDBGA4("Prefereed capability %d is not a local transmit "
+                         "capability(%s, %s)\n", call->capPrefs.order[k],
+                         call->callType, call->callToken);
+            continue;
+         }
+         break;
+      }
+      if(!epCap)
+      {
+         OOTRACEERR4("ERROR:Incompatible capabilities - Can not open "
+                  "%s channel (%s, %s)\n", 
+                  (capType==OO_CAP_TYPE_AUDIO)?"audio":"video", call->callType,
+                  call->callToken);
+         return OO_FAILED;
+      }
+
+   }
+   else if(call->masterSlaveState == OO_MasterSlave_Slave)
+   {
+      epCap = call->jointCaps;
+
+      while(epCap){
+         if(epCap->capType == capType && epCap->dir & OOTX) { break; }
+         epCap = epCap->next;
+      }
+      if(!epCap)
+      {
+         OOTRACEERR4("ERROR:Incompatible audio capabilities - Can not open "
+                  "%s channel (%s, %s)\n", 
+                  (capType==OO_CAP_TYPE_AUDIO)?"audio":"video", call->callType,
+                  call->callToken);
+         return OO_FAILED;
+      }
+       
+   }
+
+   switch(epCap->cap)
+   {
+   case OO_G711ALAW64K:
+   case OO_G711ALAW56K:
+   case OO_G711ULAW64K:
+   case OO_G711ULAW56K:
+   /*case OO_G726:*/
+   case OO_G728:
+   case OO_G729:
+   case OO_G729A:
+   case OO_G7231:
+   case OO_GSMFULLRATE:
+   case OO_H263VIDEO:
+      ooOpenChannel(call, epCap);
+      break;
+   case OO_GSMHALFRATE:
+   case OO_GSMENHANCEDFULLRATE:
+
+      
+   default:
+      OOTRACEERR3("ERROR:Unknown Audio Capability type (%s, %s)\n", 
+                   call->callType, call->callToken);
+   }
+   return OO_OK;
+}
+
+int ooOpenChannel(OOH323CallData* call, ooH323EpCapability *epCap)
+{
+   int ret;
+   H245Message *ph245msg = NULL;
+   H245RequestMessage * request;
+   OOCTXT *pctxt = NULL;
+   H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp = NULL;
+   H245AudioCapability *audioCap = NULL;
+   H245VideoCapability *videoCap = NULL;
+   H245H2250LogicalChannelParameters *h2250lcp = NULL;
+   H245UnicastAddress *unicastAddrs = NULL;
+   H245UnicastAddress_iPAddress *iPAddress = NULL;
+   unsigned session_id=0;
+   ooLogicalChannel *pLogicalChannel = NULL;
+   
+   OOTRACEDBGC4("Doing Open Channel for %s. (%s, %s)\n", 
+                 ooGetCapTypeText(epCap->cap), call->callType, 
+                 call->callToken);
+
+   ret = ooCreateH245Message(&ph245msg, 
+                      T_H245MultimediaSystemControlMessage_request);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR4("Error: H245 message creation failed for - Open %s"
+                  "channel (%s, %s)\n", ooGetCapTypeText(epCap->cap), 
+                  call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   ph245msg->msgType = OOOpenLogicalChannel;
+
+   ph245msg->logicalChannelNo =  call->logicalChanNoCur++;
+   if(call->logicalChanNoCur > call->logicalChanNoMax)
+      call->logicalChanNoCur = call->logicalChanNoBase; 
+
+   request = ph245msg->h245Msg.u.request;
+   pctxt = &gH323ep.msgctxt;
+   memset(request, 0, sizeof(H245RequestMessage));
+
+   request->t = T_H245RequestMessage_openLogicalChannel;
+   request->u.openLogicalChannel = (H245OpenLogicalChannel*)
+                     memAlloc(pctxt, sizeof(H245OpenLogicalChannel));
+   if(!request->u.openLogicalChannel)
+   {
+      OOTRACEERR3("Error:Memory - ooOpenChannel - openLogicalChannel."
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+
+   }
+   memset(request->u.openLogicalChannel, 0, 
+                                     sizeof(H245OpenLogicalChannel));
+   request->u.openLogicalChannel->forwardLogicalChannelNumber = 
+                                                 ph245msg->logicalChannelNo;
+
+   
+   session_id = ooCallGenerateSessionID(call, epCap->capType, "transmit");
+
+
+   pLogicalChannel = ooAddNewLogicalChannel(call, 
+                   request->u.openLogicalChannel->forwardLogicalChannelNumber,
+                   session_id, "transmit", epCap);
+   
+   if(!pLogicalChannel)
+   {
+      OOTRACEERR3("ERROR:Failed to add new logical channel entry (%s, %s)\n",
+                  call->callType, call->callToken);
+      ooFreeH245Message(call, ph245msg);
+      return OO_FAILED;
+   }
+   /* Populate H245OpenLogicalChannel_ForwardLogicalChannel Parameters*/
+   flcp = &(request->u.openLogicalChannel->forwardLogicalChannelParameters);
+   flcp->m.portNumberPresent = 0;
+   flcp->m.forwardLogicalChannelDependencyPresent = 0;
+   flcp->m.replacementForPresent = 0;
+
+   /* data type of channel */
+   if(epCap->capType == OO_CAP_TYPE_AUDIO)
+   {
+      flcp->dataType.t = T_H245DataType_audioData;
+      /* set audio capability for channel */
+      audioCap = ooCapabilityCreateAudioCapability(epCap,pctxt, OOTX);
+      if(!audioCap)
+      {
+         OOTRACEERR4("Error:Failed to create duplicate audio capability in "
+                     "ooOpenChannel- %s (%s, %s)\n", 
+                     ooGetCapTypeText(epCap->cap), call->callType, 
+                     call->callToken);
+         ooFreeH245Message(call, ph245msg);
+         return OO_FAILED;
+      }
+   
+      flcp->dataType.u.audioData = audioCap;
+   }
+   else if(epCap->capType == OO_CAP_TYPE_VIDEO)
+   {
+      flcp->dataType.t = T_H245DataType_videoData;      
+      videoCap = ooCapabilityCreateVideoCapability(epCap, pctxt, OOTX);
+      if(!videoCap)
+      {
+         OOTRACEERR4("Error:Failed to create duplicate video capability in "
+                     "ooOpenChannel- %s (%s, %s)\n", 
+                     ooGetCapTypeText(epCap->cap), call->callType, 
+                     call->callToken);
+         ooFreeH245Message(call, ph245msg);
+         return OO_FAILED;
+      }
+   
+      flcp->dataType.u.videoData = videoCap;
+   }
+   else{
+      OOTRACEERR1("Error: Unhandled media type in ooOpenChannel\n");
+      return OO_FAILED;
+   }
+
+  
+   flcp->multiplexParameters.t = 
+      T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters;
+   flcp->multiplexParameters.u.h2250LogicalChannelParameters = 
+                         (H245H2250LogicalChannelParameters*)ASN1MALLOC(pctxt, 
+                          sizeof(H245H2250LogicalChannelParameters));
+
+   h2250lcp = flcp->multiplexParameters.u.h2250LogicalChannelParameters;
+   memset(h2250lcp, 0, sizeof(H245H2250LogicalChannelParameters));
+
+   h2250lcp->sessionID = session_id;
+
+   h2250lcp->mediaGuaranteedDelivery = 0;
+   h2250lcp->silenceSuppression = 0;
+   h2250lcp->m.mediaControlChannelPresent = 1;
+   
+   h2250lcp->mediaControlChannel.t = 
+                                 T_H245TransportAddress_unicastAddress;
+   h2250lcp->mediaControlChannel.u.unicastAddress =  (H245UnicastAddress*)
+                         ASN1MALLOC(pctxt, sizeof(H245UnicastAddress));
+
+   unicastAddrs = h2250lcp->mediaControlChannel.u.unicastAddress;
+   memset(unicastAddrs, 0, sizeof(H245UnicastAddress));
+   unicastAddrs->t = T_H245UnicastAddress_iPAddress;
+   unicastAddrs->u.iPAddress = (H245UnicastAddress_iPAddress*)
+               ASN1MALLOC(pctxt, sizeof(H245UnicastAddress_iPAddress));
+   iPAddress = unicastAddrs->u.iPAddress;
+   memset(iPAddress, 0, sizeof(H245UnicastAddress_iPAddress));
+
+   ooSocketConvertIpToNwAddr(pLogicalChannel->localIP,iPAddress->network.data);
+
+   iPAddress->network.numocts = 4;
+   iPAddress->tsapIdentifier = pLogicalChannel->localRtcpPort;
+   pLogicalChannel->state = OO_LOGICALCHAN_PROPOSED; 
+   OOTRACEDBGA4("Built OpenLogicalChannel-%s (%s, %s)\n", 
+                 ooGetCapTypeText(epCap->cap), call->callType, 
+                 call->callToken);
+   ret = ooSendH245Msg(call, ph245msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue OpenLogicalChannel to outbound "
+                 "queue. (%s, %s)\n", call->callType,
+                 call->callToken);
+   }
+   ooFreeH245Message(call, ph245msg);
+  
+    return ret;
+}
+
+
+/* Used to build  OLCs for fast connect. Keep in mind that forward and 
+   reverse 
+   are always with respect to the endpoint which proposes channels 
+   TODO: Need to clean logical channel in case of failure.    */
+int ooBuildFastStartOLC
+   (OOH323CallData *call, H245OpenLogicalChannel *olc, 
+    ooH323EpCapability *epCap, OOCTXT*pctxt, int dir)
+{
+   OOBOOL reverse=FALSE, forward=FALSE;
+   unsigned sessionID=0;
+   H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp=NULL;
+   H245OpenLogicalChannel_reverseLogicalChannelParameters *rlcp=NULL;
+   H245H2250LogicalChannelParameters *pH2250lcp1=NULL, *pH2250lcp2=NULL;
+   H245UnicastAddress *pUnicastAddrs=NULL, *pUniAddrs=NULL;
+   H245UnicastAddress_iPAddress *pIpAddrs=NULL, *pUniIpAddrs=NULL;
+   unsigned session_id = 0;
+   ooLogicalChannel *pLogicalChannel = NULL;
+   int outgoing=FALSE;
+
+   if(!strcmp(call->callType, "outgoing"))   
+      outgoing = TRUE;
+   
+   if(dir & OORX)
+   {
+      OOTRACEDBGA3("Building OpenLogicalChannel for Receive  Capability "
+                   "(%s, %s)\n", call->callType, call->callToken);
+      session_id = ooCallGenerateSessionID(call, epCap->capType, "receive");
+      pLogicalChannel = ooAddNewLogicalChannel(call, 
+                                 olc->forwardLogicalChannelNumber, session_id, 
+                                 "receive", epCap);
+      if(outgoing)
+         reverse = TRUE;
+      else
+         forward = TRUE;
+   }
+   else if(dir & OOTX)
+   {
+      OOTRACEDBGA3("Building OpenLogicalChannel for transmit Capability "
+                   "(%s, %s)\n", call->callType, call->callToken);
+      session_id = ooCallGenerateSessionID(call, epCap->capType, "transmit");
+      pLogicalChannel = ooAddNewLogicalChannel(call, 
+                                  olc->forwardLogicalChannelNumber, session_id,
+                                  "transmit", epCap);
+      if(outgoing)
+         forward = TRUE;
+      else
+         reverse = TRUE;
+   }
+   else if(dir & OORXTX)
+   {
+      OOTRACEDBGA3("Building OpenLogicalChannel for ReceiveAndTransmit  "
+                   "Capability (%s, %s)\n", call->callType, call->callToken);
+      reverse = 1;
+      forward = 1;
+      OOTRACEERR3("Symmetric capability is not supported as of now (%s, %s)\n",
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   if(forward)
+   {
+      OOTRACEDBGC3("Building forward olc. (%s, %s)\n", call->callType, 
+                    call->callToken);
+      flcp = &(olc->forwardLogicalChannelParameters);
+      memset(flcp, 0, 
+             sizeof(H245OpenLogicalChannel_forwardLogicalChannelParameters));
+
+      if(epCap->capType == OO_CAP_TYPE_AUDIO) {
+         sessionID =1;
+         flcp->dataType.t = T_H245DataType_audioData;
+         flcp->dataType.u.audioData = ooCapabilityCreateAudioCapability(epCap, 
+                                                                   pctxt, dir);
+      }
+      else if(epCap->capType == OO_CAP_TYPE_VIDEO) {
+         sessionID = 2;
+         flcp->dataType.t = T_H245DataType_videoData;
+         flcp->dataType.u.videoData = ooCapabilityCreateVideoCapability(epCap,
+                                                                   pctxt, dir);
+      }
+      flcp->multiplexParameters.t = T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters;
+      pH2250lcp1 = (H245H2250LogicalChannelParameters*)ASN1MALLOC(pctxt, 
+                                    sizeof(H245H2250LogicalChannelParameters));
+      memset(pH2250lcp1, 0, sizeof(H245H2250LogicalChannelParameters));
+      flcp->multiplexParameters.t = T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters;
+      
+      flcp->multiplexParameters.u.h2250LogicalChannelParameters = pH2250lcp1;
+          
+      pH2250lcp1->sessionID = sessionID;
+      if(!outgoing)
+      {
+         pH2250lcp1->m.mediaChannelPresent = 1;
+         pH2250lcp1->mediaChannel.t = 
+                                    T_H245TransportAddress_unicastAddress;
+         pUniAddrs = (H245UnicastAddress*) ASN1MALLOC(pctxt, 
+                                                   sizeof(H245UnicastAddress));
+         memset(pUniAddrs, 0, sizeof(H245UnicastAddress));
+         pH2250lcp1->mediaChannel.u.unicastAddress =  pUniAddrs;
+         pUniAddrs->t = T_H245UnicastAddress_iPAddress;
+         pUniIpAddrs = (H245UnicastAddress_iPAddress*) ASN1MALLOC(pctxt, 
+                                         sizeof(H245UnicastAddress_iPAddress));
+         memset(pUniIpAddrs, 0, sizeof(H245UnicastAddress_iPAddress));
+         pUniAddrs->u.iPAddress = pUniIpAddrs;
+     
+         ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, 
+                                                pUniIpAddrs->network.data);
+
+         pUniIpAddrs->network.numocts = 4;
+         pUniIpAddrs->tsapIdentifier = pLogicalChannel->localRtpPort;
+      }
+      pH2250lcp1->m.mediaControlChannelPresent = 1;
+      pH2250lcp1->mediaControlChannel.t = 
+                                 T_H245TransportAddress_unicastAddress;
+      pUnicastAddrs = (H245UnicastAddress*) ASN1MALLOC(pctxt, 
+                                                   sizeof(H245UnicastAddress));
+      memset(pUnicastAddrs, 0, sizeof(H245UnicastAddress));
+      pH2250lcp1->mediaControlChannel.u.unicastAddress =  pUnicastAddrs;
+      pUnicastAddrs->t = T_H245UnicastAddress_iPAddress;
+      pIpAddrs = (H245UnicastAddress_iPAddress*) ASN1MALLOC(pctxt, 
+                                         sizeof(H245UnicastAddress_iPAddress));
+      memset(pIpAddrs, 0, sizeof(H245UnicastAddress_iPAddress));
+      pUnicastAddrs->u.iPAddress = pIpAddrs;
+     
+       ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, 
+                                                      pIpAddrs->network.data);
+
+      pIpAddrs->network.numocts = 4;
+      pIpAddrs->tsapIdentifier = pLogicalChannel->localRtcpPort;
+      if(!outgoing)
+      {
+         if(epCap->startReceiveChannel)
+         {   
+            epCap->startReceiveChannel(call, pLogicalChannel);      
+            OOTRACEINFO4("Receive channel of type %s started (%s, %s)\n", 
+                        (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video",
+                        call->callType, call->callToken);
+         }
+         else{
+            OOTRACEERR4("ERROR:No callback registered to start receive %s"
+                       " channel (%s, %s)\n", 
+                        (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", 
+                        call->callType, call->callToken);
+            return OO_FAILED;
+         }
+      }
+   }
+
+   if(reverse)
+   {
+      OOTRACEDBGC3("Building reverse olc. (%s, %s)\n", call->callType, 
+                    call->callToken);
+      olc->forwardLogicalChannelParameters.dataType.t = 
+                                                      T_H245DataType_nullData;
+      olc->forwardLogicalChannelParameters.multiplexParameters.t = 
+         T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_none;
+      olc->m.reverseLogicalChannelParametersPresent = 1;
+      rlcp = &(olc->reverseLogicalChannelParameters);
+      memset(rlcp, 0, sizeof(H245OpenLogicalChannel_reverseLogicalChannelParameters));
+      if(epCap->capType == OO_CAP_TYPE_AUDIO) {
+         sessionID = 1;
+         rlcp->dataType.t = T_H245DataType_audioData;
+  
+         rlcp->dataType.u.audioData = ooCapabilityCreateAudioCapability(epCap, 
+                                                                   pctxt, dir);
+      }
+      else if(epCap->capType == OO_CAP_TYPE_VIDEO)  {
+         sessionID = 2;
+         rlcp->dataType.t = T_H245DataType_videoData;
+  
+         rlcp->dataType.u.videoData = ooCapabilityCreateVideoCapability(epCap, 
+                                                                   pctxt, dir);
+      }
+
+      rlcp->m.multiplexParametersPresent = 1;
+      rlcp->multiplexParameters.t = T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters;
+      pH2250lcp2 = (H245H2250LogicalChannelParameters*) ASN1MALLOC(pctxt, sizeof(H245H2250LogicalChannelParameters));
+      rlcp->multiplexParameters.u.h2250LogicalChannelParameters = pH2250lcp2;
+      memset(pH2250lcp2, 0, sizeof(H245H2250LogicalChannelParameters));
+      pH2250lcp2->sessionID = sessionID;
+
+      if(outgoing)
+      {
+         pH2250lcp2->m.mediaChannelPresent = 1;
+
+         pH2250lcp2->mediaChannel.t = 
+                                    T_H245TransportAddress_unicastAddress;
+         pUnicastAddrs = (H245UnicastAddress*) memAlloc(pctxt, 
+                                                  sizeof(H245UnicastAddress));
+         memset(pUnicastAddrs, 0, sizeof(H245UnicastAddress));
+         pH2250lcp2->mediaChannel.u.unicastAddress =  pUnicastAddrs;
+      
+         pUnicastAddrs->t = T_H245UnicastAddress_iPAddress;
+         pIpAddrs = (H245UnicastAddress_iPAddress*) memAlloc(pctxt, 
+                                         sizeof(H245UnicastAddress_iPAddress));
+         memset(pIpAddrs, 0, sizeof(H245UnicastAddress_iPAddress));
+         pUnicastAddrs->u.iPAddress = pIpAddrs;      
+
+         ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, 
+                                                       pIpAddrs->network.data);
+
+         pIpAddrs->network.numocts = 4;
+         pIpAddrs->tsapIdentifier = pLogicalChannel->localRtpPort;
+      }
+      pH2250lcp2->m.mediaControlChannelPresent = 1;
+      pH2250lcp2->mediaControlChannel.t = 
+                                 T_H245TransportAddress_unicastAddress;
+      pUniAddrs = (H245UnicastAddress*) ASN1MALLOC(pctxt, sizeof(H245UnicastAddress));
+      
+      memset(pUniAddrs, 0, sizeof(H245UnicastAddress));
+      pH2250lcp2->mediaControlChannel.u.unicastAddress =  pUniAddrs;
+
+      
+      pUniAddrs->t = T_H245UnicastAddress_iPAddress;
+      pUniIpAddrs = (H245UnicastAddress_iPAddress*) ASN1MALLOC(pctxt, sizeof(H245UnicastAddress_iPAddress));
+      memset(pUniIpAddrs, 0, sizeof(H245UnicastAddress_iPAddress));
+      pUniAddrs->u.iPAddress = pUniIpAddrs; 
+
+      ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, 
+                                                    pUniIpAddrs->network.data);
+      pUniIpAddrs->network.numocts = 4;
+      pUniIpAddrs->tsapIdentifier = pLogicalChannel->localRtcpPort;
+          
+      /*
+         In case of fast start, the local endpoint need to be ready to
+         receive all the media types proposed in the fast connect, before
+         the actual call is established.
+      */
+      if(outgoing)
+      {
+         if(epCap->startReceiveChannel)
+         {
+            epCap->startReceiveChannel(call, pLogicalChannel);      
+            OOTRACEINFO4("Receive channel of type %s started (%s, %s)\n",
+                         (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video",
+                          call->callType, call->callToken);
+         }
+         else{
+            OOTRACEERR4("ERROR:No callback registered to start receive %s "
+                        "channel (%s, %s)\n", 
+                        (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", 
+                        call->callType, call->callToken);
+            return OO_FAILED;
+         }
+      }
+   }
+
+   /* State of logical channel. for out going calls, as we are sending setup, 
+      state of all channels are proposed, for incoming calls, state is 
+      established. */
+   if(!outgoing) {
+      pLogicalChannel->state = OO_LOGICALCHAN_ESTABLISHED;
+   }
+   else {
+      /* Calling other ep, with SETUP message */
+      /* Call is "outgoing */
+      pLogicalChannel->state = OO_LOGICALCHAN_PROPOSED;
+   }
+   
+   return OO_OK;
+}
+
+
+
+int ooMSDTimerExpired(void *data)
+{
+   ooTimerCallback *cbData = (ooTimerCallback*)data;
+   OOH323CallData *call = cbData->call;
+   OOTRACEINFO3("MasterSlaveDetermination timeout. (%s, %s)\n", call->callType,
+                 call->callToken);
+   ASN1MEMFREEPTR(call->pctxt, cbData);
+   ooSendMasterSlaveDeterminationRelease(call);
+   if(call->callState < OO_CALL_CLEAR)
+   {
+      call->callState = OO_CALL_CLEAR;
+      call->callEndReason = OO_REASON_LOCAL_CLEARED;
+   }
+
+   return OO_OK;
+}
+   
+int ooTCSTimerExpired(void *data)
+{
+   ooTimerCallback *cbData = (ooTimerCallback*)data;
+   OOH323CallData *call = cbData->call;
+   OOTRACEINFO3("TerminalCapabilityExchange timeout. (%s, %s)\n", 
+                 call->callType, call->callToken);
+   ASN1MEMFREEPTR(call->pctxt, cbData);
+   ooSendTerminalCapabilitySetRelease(call);
+   if(call->callState < OO_CALL_CLEAR)
+   {
+      call->callState = OO_CALL_CLEAR;
+      call->callEndReason = OO_REASON_LOCAL_CLEARED;
+   }
+
+   return OO_OK;
+}
+
+int ooOpenLogicalChannelTimerExpired(void *pdata)
+{
+   ooTimerCallback *cbData = (ooTimerCallback*)pdata;
+   OOH323CallData *call = cbData->call;
+   ooLogicalChannel *pChannel = NULL;
+   OOTRACEINFO3("OpenLogicalChannelTimer expired. (%s, %s)\n", call->callType,
+                 call->callToken);
+   pChannel = ooFindLogicalChannelByLogicalChannelNo(call, 
+                                               cbData->channelNumber);
+   if(pChannel)
+      ooSendCloseLogicalChannel(call, pChannel);
+   
+   if(call->callState < OO_CALL_CLEAR)
+   {
+      call->callState = OO_CALL_CLEAR;
+      call->callEndReason = OO_REASON_LOCAL_CLEARED;
+   }
+   ASN1MEMFREEPTR(call->pctxt, cbData);
+   return OO_OK;
+}
+
+int ooCloseLogicalChannelTimerExpired(void *pdata)
+{
+   ooTimerCallback *cbData = (ooTimerCallback*)pdata;
+   OOH323CallData *call = cbData->call;
+
+   OOTRACEINFO3("CloseLogicalChannelTimer expired. (%s, %s)\n", call->callType,
+                 call->callToken);
+
+   ooClearLogicalChannel(call, cbData->channelNumber);
+   
+   if(call->callState < OO_CALL_CLEAR)
+   {
+      call->callState = OO_CALL_CLEAR;
+      call->callEndReason = OO_REASON_LOCAL_CLEARED;
+   }
+   ASN1MEMFREEPTR(call->pctxt, cbData);
+   return OO_OK;
+}
+
+int ooRequestChannelCloseTimerExpired(void *pdata)
+{
+   int ret = 0;
+   ooTimerCallback *cbData = (ooTimerCallback*)pdata;
+   OOH323CallData *call = cbData->call;
+
+   OOTRACEINFO3("OpenLogicalChannelTimer expired. (%s, %s)\n", call->callType,
+                 call->callToken);
+  
+   ooSendRequestChannelCloseRelease(call, cbData->channelNumber);
+
+   ret = ooClearLogicalChannel(call, cbData->channelNumber);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR4("Error:Failed to clear logical channel %d. (%s, %s)\n",
+                   cbData->channelNumber, call->callType, call->callToken);
+   } 
+
+   if(call->callState < OO_CALL_CLEAR)
+   {
+      call->callState = OO_CALL_CLEAR;
+      call->callEndReason = OO_REASON_LOCAL_CLEARED;
+   }
+   ASN1MEMFREEPTR(call->pctxt, cbData);
+   return OO_OK;
+}
+
+int ooSessionTimerExpired(void *pdata)
+{
+   int ret = 0;
+   ooTimerCallback *cbData = (ooTimerCallback*)pdata;
+   OOH323CallData *call = cbData->call;
+
+   OOTRACEINFO3("SessionTimer expired. (%s, %s)\n", call->callType,
+                 call->callToken);
+
+   if(call->h245SessionState != OO_H245SESSION_IDLE && 
+      call->h245SessionState != OO_H245SESSION_CLOSED &&
+      call->h245SessionState != OO_H245SESSION_PAUSED) {
+
+      ret = ooCloseH245Connection(call);
+   
+      if(ret != OO_OK) {
+         OOTRACEERR3("Error:Failed to close H.245 connection (%s, %s)\n",
+                     call->callType, call->callToken);
+      } 
+   }
+
+   memFreePtr(call->pctxt, cbData);
+
+   if(call->callState == OO_CALL_CLEAR_RELEASESENT)
+      call->callState = OO_CALL_CLEARED;
+   
+   return OO_OK;
+}
+
+
+int ooGetIpPortFromH245TransportAddress
+   (OOH323CallData *call, H245TransportAddress *h245Address, char *ip, 
+    int *port)
+{
+   H245UnicastAddress *unicastAddress = NULL;
+   H245UnicastAddress_iPAddress *ipAddress = NULL;
+
+   if(h245Address->t != T_H245TransportAddress_unicastAddress)
+   {
+      OOTRACEERR3("ERROR:Unsupported H245 address type "
+                           "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   } 
+      
+   unicastAddress = h245Address->u.unicastAddress;
+   if(unicastAddress->t != T_H245UnicastAddress_iPAddress)
+   {
+      OOTRACEERR3("ERROR:H245 Address type is not IP"
+                   "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ipAddress = unicastAddress->u.iPAddress;
+
+   *port = ipAddress->tsapIdentifier;
+
+   sprintf(ip, "%d.%d.%d.%d", ipAddress->network.data[0], 
+                              ipAddress->network.data[1],
+                              ipAddress->network.data[2],
+                              ipAddress->network.data[3]);
+   return OO_OK;
+}
+
+
+int ooPrepareFastStartResponseOLC
+   (OOH323CallData *call, H245OpenLogicalChannel *olc, 
+    ooH323EpCapability *epCap, OOCTXT*pctxt, int dir)
+{
+   OOBOOL reverse=FALSE, forward=FALSE;
+   H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp=NULL;
+   H245OpenLogicalChannel_reverseLogicalChannelParameters *rlcp=NULL;
+   H245H2250LogicalChannelParameters *pH2250lcp1=NULL, *pH2250lcp2=NULL;
+   H245UnicastAddress *pUnicastAddrs=NULL, *pUniAddrs=NULL;
+   H245UnicastAddress_iPAddress *pIpAddrs=NULL, *pUniIpAddrs=NULL;
+   unsigned session_id = 0;
+   ooLogicalChannel *pLogicalChannel = NULL;
+   
+   if(dir & OORX)
+   {
+      OOTRACEDBGA3("ooPrepareFastStartResponseOLC for Receive  Capability "
+                   "(%s, %s)\n", call->callType, call->callToken);
+      session_id = ooCallGenerateSessionID(call, epCap->capType, "receive");
+      pLogicalChannel = ooAddNewLogicalChannel(call, 
+                                 olc->forwardLogicalChannelNumber, session_id, 
+                                 "receive", epCap);
+      forward = TRUE;
+   }
+   else if(dir & OOTX)
+   {
+      OOTRACEDBGA3("ooPrepareFastStartResponseOLC for transmit Capability "
+                   "(%s, %s)\n", call->callType, call->callToken);
+      session_id = ooCallGenerateSessionID(call, epCap->capType, "transmit");
+      pLogicalChannel = ooAddNewLogicalChannel(call, 
+                                  olc->forwardLogicalChannelNumber, session_id,
+                                  "transmit", epCap);
+      reverse = TRUE;
+   }
+   else if(dir & OORXTX)
+   {
+      OOTRACEDBGA3("ooPrepareFastStartResponseOLC for ReceiveAndTransmit  "
+                   "Capability (%s, %s)\n", call->callType, call->callToken);
+      reverse = 1;
+      forward = 1;
+      OOTRACEERR3("Symmetric capability is not supported as of now (%s, %s)\n",
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   if(forward)
+   {
+      OOTRACEDBGC3("Preparing olc for receive channel. (%s, %s)\n", 
+                   call->callType, call->callToken);
+      flcp = &(olc->forwardLogicalChannelParameters);
+
+      pH2250lcp1 = flcp->multiplexParameters.u.h2250LogicalChannelParameters;
+          
+
+      pH2250lcp1->m.mediaChannelPresent = 1;
+      pH2250lcp1->mediaChannel.t = T_H245TransportAddress_unicastAddress;
+      pUniAddrs = (H245UnicastAddress*) memAlloc(pctxt, 
+                                                   sizeof(H245UnicastAddress));
+      pUniIpAddrs = (H245UnicastAddress_iPAddress*) memAlloc(pctxt, 
+                                         sizeof(H245UnicastAddress_iPAddress));
+      if(!pUniAddrs || !pUniIpAddrs)
+      {
+         OOTRACEERR3("Error:Memory - ooPrepareFastStartResponseOLC - pUniAddrs"
+                     "/pUniIpAddrs (%s, %s)\n", call->callType, 
+                     call->callToken);
+         return OO_FAILED;
+      }
+
+      pH2250lcp1->mediaChannel.u.unicastAddress =  pUniAddrs;
+      pUniAddrs->t = T_H245UnicastAddress_iPAddress;
+      pUniAddrs->u.iPAddress = pUniIpAddrs;
+     
+      ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, 
+                                                    pUniIpAddrs->network.data);
+
+      pUniIpAddrs->network.numocts = 4;
+      pUniIpAddrs->tsapIdentifier = pLogicalChannel->localRtpPort;
+
+      pH2250lcp1->m.mediaControlChannelPresent = 1;
+      pH2250lcp1->mediaControlChannel.t = 
+                                 T_H245TransportAddress_unicastAddress;
+      pUnicastAddrs = (H245UnicastAddress*) memAlloc(pctxt, 
+                                                   sizeof(H245UnicastAddress));
+      pIpAddrs = (H245UnicastAddress_iPAddress*) memAlloc(pctxt, 
+                                         sizeof(H245UnicastAddress_iPAddress));
+      if(!pUnicastAddrs || !pIpAddrs)
+      {
+         OOTRACEERR3("Error:Memory - ooPrepareFastStartResponseOLC - "
+                     "pUnicastAddrs/pIpAddrs (%s, %s)\n", call->callType, 
+                     call->callToken);
+         return OO_FAILED;
+      }
+      memset(pUnicastAddrs, 0, sizeof(H245UnicastAddress));
+      pH2250lcp1->mediaControlChannel.u.unicastAddress =  pUnicastAddrs;
+      pUnicastAddrs->t = T_H245UnicastAddress_iPAddress;
+      
+      pUnicastAddrs->u.iPAddress = pIpAddrs;
+     
+      ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, 
+                                                       pIpAddrs->network.data);
+
+      pIpAddrs->network.numocts = 4;
+      pIpAddrs->tsapIdentifier = pLogicalChannel->localRtcpPort;
+   }
+
+   if(reverse)
+   {
+      OOTRACEDBGC3("Building reverse olc. (%s, %s)\n", call->callType, 
+                    call->callToken);
+
+      rlcp = &(olc->reverseLogicalChannelParameters);
+
+      pH2250lcp2 = rlcp->multiplexParameters.u.h2250LogicalChannelParameters;
+      pH2250lcp2->m.mediaChannelPresent = 0;
+      memset(&pH2250lcp2->mediaChannel, 0, sizeof(H245TransportAddress));
+
+      pH2250lcp2->m.mediaControlChannelPresent = 1;
+      pH2250lcp2->mediaControlChannel.t = 
+                                 T_H245TransportAddress_unicastAddress;
+      pUniAddrs = (H245UnicastAddress*) memAlloc(pctxt, 
+                                                   sizeof(H245UnicastAddress));
+      pUniIpAddrs = (H245UnicastAddress_iPAddress*) memAlloc(pctxt, 
+                                         sizeof(H245UnicastAddress_iPAddress));
+      if(!pUniAddrs || !pUniIpAddrs)
+      {
+         OOTRACEERR3("Error:Memory - ooPrepareFastStartResponseOLC - "
+                    "pUniAddrs/pUniIpAddrs (%s, %s)\n", call->callType, 
+                     call->callToken);
+         return OO_FAILED;
+      }
+
+      pH2250lcp2->mediaControlChannel.u.unicastAddress =  pUniAddrs;
+      
+      pUniAddrs->t = T_H245UnicastAddress_iPAddress;
+
+      pUniAddrs->u.iPAddress = pUniIpAddrs; 
+
+      ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, 
+                                                    pUniIpAddrs->network.data);
+      pUniIpAddrs->network.numocts = 4;
+      pUniIpAddrs->tsapIdentifier = pLogicalChannel->localRtcpPort;
+          
+   }
+
+   pLogicalChannel->state = OO_LOGICALCHAN_ESTABLISHED;
+
+   return OO_OK;
+}
+
+
+
diff --git a/addons/ooh323c/src/ooh245.h b/addons/ooh323c/src/ooh245.h
new file mode 100644
index 000000000..10a8750a8
--- /dev/null
+++ b/addons/ooh323c/src/ooh245.h
@@ -0,0 +1,636 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/**
+ * @file ooh245.h 
+ * This file contains functions to support H245 negotiations. 
+ */
+#ifndef _OOH245HDR_H_
+#define _OOH245HDR_H_
+
+#include "ooasn1.h"
+#include "ooCapability.h"
+#include "oochannels.h"
+#include "ootrace.h"
+
+#include "ooq931.h"
+#include "MULTIMEDIA-SYSTEM-CONTROL.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+struct OOH323CallData;
+
+/** 
+ * @defgroup h245 H.245 Message Handling
+ * @{
+ */
+/**
+ * Defines the H.245 message structure. All request/response
+ * and command messages are represented using this structure.
+ */
+typedef struct H245Message {
+   H245MultimediaSystemControlMessage h245Msg;
+   ASN1UINT msgType;
+   ASN1INT  logicalChannelNo;
+} H245Message;
+
+/**
+ * Creates an outgoing H245 message of the type specified by the type
+ * argument for the Application context. 
+ *
+ * @param msg       A pointer to pointer to message which will be assigned to 
+ *                  allocated memory.
+ * @param type      Type of the message to be created.
+ *                  (Request/Response/Command/Indication)
+ *
+ * @return          Completion status of operation: 0 (OO_OK) = success,
+ *                  negative return value is error.         
+ */
+EXTERN int ooCreateH245Message(H245Message **msg, int type);
+
+/**
+ * Frees up the memory used by the H245 message.
+ *
+ * @param call      Handle to the call
+ * @param pmsg      Pointer to an H245 message structure.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure         
+ */
+EXTERN int ooFreeH245Message(struct OOH323CallData *call, H245Message *pmsg);
+
+/**
+ * This function is used to enqueue an H.245 message into an outgoing queue for
+ * the call.
+ * @param call      Pointer to call for which message has to be enqueued.
+ * @param msg       Pointer to the H.245 message to be sent.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooSendH245Msg(struct OOH323CallData *call, H245Message *msg);
+
+/**
+ * This function is used to retrieve an H.245 message enqueued in the outgoing 
+ * queue. 
+ * @param call      Pointer to the call for which message has to be retrieved.
+ * @param msgbuf    Pointer to a buffer in which the message will be returned.
+ * @param len       Pointer to an int variable which will contain length of
+ *                  the message data after returning.
+ * @param msgType   Pointer to an int variable, which will contain message type
+ *                  on return from the function.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGetOutgoingH245Msgbuf(struct OOH323CallData *call, 
+                                   ASN1OCTET *msgbuf, 
+                                   int *len, int *msgType);
+
+/**
+ * This function is used to send out a terminal capability set message. 
+ *
+ * @param call      Pointer to a call for which TerminalCapabilitySet message
+ *                  will be sent.
+ * 
+ * @return          OO_OK, on success. OO_FAILED, on failure.  
+ */
+EXTERN int ooSendTermCapMsg(struct OOH323CallData *call);
+
+/**
+ * This function is used to generate a random status determination number
+ * for MSD procedure.
+ *
+ * @return          Generated status determination number.
+ */
+EXTERN ASN1UINT ooGenerateStatusDeterminationNumber();
+
+/**
+ * This fuction is used to handle received MasterSlaveDetermination procedure
+ * messages. 
+ * @param call       Pointer to the call for which a message is received.
+ * @param pmsg       Pointer to MSD message
+ * @param msgType    Message type indicating whether received message is MSD, 
+ *                   MSDAck, MSDReject etc...
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooHandleMasterSlave
+(struct OOH323CallData *call, void * pmsg, int msgType);
+
+/**
+ * This function is used to send MSD message.
+ * @param call       Pointer to call for which MasterSlaveDetermination has to
+ *                   be sent.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooSendMasterSlaveDetermination(struct OOH323CallData *call);
+
+/**
+ * This function is used to send a MasterSlaveDeterminationAck message.
+ * @param call        Pointer to call for which MasterSlaveDeterminationAck has
+ *                    to be sent.
+ * @param status      Result of the determination process(Master/Slave as it 
+ *                    applies to remote endpoint)
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */ 
+EXTERN int ooSendMasterSlaveDeterminationAck
+(struct OOH323CallData* call, char * status);
+
+/**
+ * This function is used to send a MasterSlaveDeterminationReject message.
+ * @param call        Pointer to call for which message is to be sent.
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */ 
+EXTERN int ooSendMasterSlaveDeterminationReject (struct OOH323CallData* call);
+
+
+/**
+ * This function is used to handle MasterSlaveReject message. If number of
+ * retries is less than max allowed, then it restarts the 
+ * MasterSlaveDetermination procedure.
+ * @param call        Handle to the call for which MasterSlaveReject is 
+ *                    received.
+ * @param reject      Poinetr to the received reject message.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooHandleMasterSlaveReject
+   (struct OOH323CallData *call, H245MasterSlaveDeterminationReject* reject);
+
+/**
+ * This function is used to handle received OpenLogicalChannel message.
+ * @param call        Pointer to call for which OpenLogicalChannel message is
+ *                    received.
+ * @param olc         Pointer to the received OpenLogicalChannel message.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooHandleOpenLogicalChannel
+                   (struct OOH323CallData* call, H245OpenLogicalChannel *olc);
+
+/**
+ * This is a helper function used to handle a received OpenLogicalChannel 
+ * message. It builds an OpenLogicalChannelAck message and sends it.
+ *
+ * @param call        Pointer to cll for which OLC was received.
+ * @param olc         The received OpenLogicalChannel message.
+ * 
+ * @return            OO_OK, on success. OO_FAILED, on failure.         
+ */
+EXTERN int ooHandleOpenLogicalChannel_helper
+(struct OOH323CallData *call, H245OpenLogicalChannel*olc);
+
+/**
+ * This function is used to build and send OpenLogicalChannelReject message.
+ * @param call        Pointer to call for which OLCReject has to be sent.
+ * @param channelNum  LogicalChannelNumber to be rejected.
+ * @param cause       Cause of rejection.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooSendOpenLogicalChannelReject
+   (struct OOH323CallData *call, ASN1UINT channelNum, ASN1UINT cause);
+
+/**
+ * This function is used to handle a received OpenLogicalChannelAck message.
+ * @param call         Pointer to call for which OLCAck is received
+ * @param olcAck       Pointer to received olcAck message.
+ *
+ * @return             OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedOpenLogicalChannelAck(struct OOH323CallData *call, 
+                                            H245OpenLogicalChannelAck *olcAck);
+
+
+/**
+ * This function is used to handle the received OpenLogicalChannelReject 
+ * message.
+ * @param call         Handle to the call for which the message is received.
+ * @param olcRejected  Pointer to received OpenLogicalChannelReject message.
+ *
+ * @return             OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooOnReceivedOpenLogicalChannelRejected(struct OOH323CallData *call, 
+                                    H245OpenLogicalChannelReject *olcRejected);
+/**
+ * This message is used to send an EndSession command. It builds a EndSession 
+ * command message and queues it into the calls outgoing queue.
+ * @param call          Pointer to call for which EndSession command has to be
+ *                      sent.
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooSendEndSessionCommand(struct OOH323CallData *call);
+
+/**
+ * This function is used to handle a received H245Command message. 
+ * @param call          Pointer to call for which an H245Command is received.
+ * @param command       Pointer to a command message.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooHandleH245Command
+(struct OOH323CallData *call, H245CommandMessage *command);
+
+
+/**
+ * This function is used to handle a received UserInput Indication message.
+ * It extracts the dtmf received through user-input message and calls endpoints
+ * onReceivedDTMF callback function, if such a function is registered by the 
+ * endpoint.
+ * @param call         Handle to the call for which user-input indication
+ *                     message is received.
+ * @param indication   Handle to the received user-input indication message.
+ *
+ * @return             OO_OK, on success; OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedUserInputIndication
+   (OOH323CallData *call, H245UserInputIndication *indication);
+
+/**
+ * This function is called on receiving a TreminalCapabilitySetAck message.
+ * If the MasterSlaveDetermination process is also over, this function 
+ * initiates the process of opening logical channels.
+ * @param call          Pointer to call for which TCSAck is received.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedTerminalCapabilitySetAck(struct OOH323CallData* call);
+
+/**
+ * This function is called to close all the open logical channels. It sends
+ * CloseLogicalChannel message for all the forward channels and sends 
+ * RequestCloseLogicalChannel message for all the reverse channels.
+ * @param call          Pointer to call for which logical channels have to be 
+ *                      closed.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooCloseAllLogicalChannels(struct OOH323CallData *call);
+
+
+/**
+ * This function is used to send out a CloseLogicalChannel message for a particular
+ * logical channel.
+ * @param call           Pointer to a call, to which logical channel to be closed belongs.
+ * @param logicalChan    Pointer to the logical channel to be closed.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooSendCloseLogicalChannel
+(struct OOH323CallData *call, ooLogicalChannel *logicalChan);
+
+/**
+ * This function is used to process a received closeLogicalChannel request. It closes the
+ * logical channel and removes the logical channel entry from the list. It also, sends
+ * closeLogicalChannelAck message to the remote endpoint.
+ * @param call           Pointer to call for which CloseLogicalChannel message is received.
+ * @param clc            Pointer to received CloseLogicalChannel message.
+ * 
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedCloseLogicalChannel(struct OOH323CallData *call, 
+                                           H245CloseLogicalChannel* clc);
+
+/**
+ * This function is used to process a received CloseLogicalChannelAck message. It closes the
+ * channel and removes it from the list of active logical channels.
+ * @param call           Pointer to call for which CLCAck message is received.
+ * @param clcAck         Pointer to the received CloseLogicalChannelAck message.
+ * 
+ * @return               OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooOnReceivedCloseChannelAck(struct OOH323CallData* call, 
+                                           H245CloseLogicalChannelAck* clcAck);
+
+/**
+ * This function is used to handle received H245 message. Based on the type of message received,
+ * it calls helper functions to process those messages.
+ * @param call           Pointer to call for which a message is received.
+ * @param pmsg           Pointer to the received H245 message.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooHandleH245Message
+(struct OOH323CallData *call, H245Message * pmsg);
+
+/**
+ * This function is used to process received TCS message. It builds TCSAck message and queues it
+ * into the calls outgoing queue. Also, starts Logical channel opening procedure if TCS and MSD
+ * procedures have finished.
+ * @param call           Pointer to call for which TCS is received.
+ * @param pmsg           Pointer to the received message.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedTerminalCapabilitySet
+(struct OOH323CallData *call, H245Message *pmsg);
+
+/**
+ * This function is used to send a TCSAck message to remote endpoint.
+ * @param call           Pointer to call on which TCSAck has to be sent.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH245AcknowledgeTerminalCapabilitySet(struct OOH323CallData *call);
+
+/**
+ * This function is used to start OpenLogicalChannel procedure for all the
+ * channels to be opened for the call.
+ * @param call            Pointer to call for which logical channels have to be opened.
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure.
+ */ 
+EXTERN int ooOpenLogicalChannels(struct OOH323CallData *call);
+
+/**
+ * This function is used to send OpenLogicalChannel message for audio/video 
+ * channel.
+ * @param call            Pointer to call for which  channel has to be opened.
+ * @param capType         Type of media channel.
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOpenLogicalChannel(struct OOH323CallData *call, 
+                                enum OOCapType capType);
+
+/**
+ * This function is used to build and send OpenLogicalChannel message using
+ *  capability passed as parameter.
+ * @param call            Pointer to call for which OpenLogicalChannel message 
+ *                        has to be built.
+ * @param epCap           Pointer to capability
+ * 
+ * @return                OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOpenChannel
+(struct OOH323CallData* call, ooH323EpCapability *epCap);
+
+/**
+ * This function is used to send dtmf digits as user input indication message
+ * contating alphanumeric string.
+ * @param call            Handle to the call for which dtmf has to be sent.
+ * @param data            DTMF data
+ *
+ * @return                OO_OK, on success; OO_FAILED, on failure.
+ */
+EXTERN int ooSendH245UserInputIndication_alphanumeric
+   (OOH323CallData *call, const char *data);
+
+/**
+ * This function is used to send dtmf digits as user input indication message
+ * contating dtmf signal type.
+ * @param call            Handle to the call for which dtmf has to be sent.
+ * @param data            DTMF data
+ *
+ * @return                OO_OK, on success; OO_FAILED, on failure.
+ */
+EXTERN int ooSendH245UserInputIndication_signal
+   (OOH323CallData *call, const char *data);
+
+/**
+ * This function is used to request a remote end point to close a logical
+ * channel. 
+ * @param call            Pointer to call for which the logical channel has to
+ *                        be closed.
+ * @param logicalChan     Pointer to the logical channel structure which needs
+ *                        to be closed.
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooSendRequestCloseLogicalChannel(struct OOH323CallData *call, 
+                                            ooLogicalChannel *logicalChan);
+
+/**
+ * This function is used to send a RequestChannelCloseRelease message when the
+ * corresponding timer has expired.
+ * @param call            Handle to the call
+ * @param channelNum      Channel number.
+ *
+ * @return                OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooSendRequestChannelCloseRelease
+(struct OOH323CallData *call, int channelNum);
+
+/**
+ * This function handles the received RequestChannelClose message, verifies
+ * that the requested channel is forward channel. It sends an acknowledgement
+ * for the message followed by CloseLogicalChannel message.
+ * @param call             Pointer to the call for which RequestChannelClose is
+ *                         received.
+ * @param rclc             Pointer to the received message.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedRequestChannelClose(struct OOH323CallData *call, 
+                                           H245RequestChannelClose *rclc);
+
+/**
+ * This function is used to handle a received RequestChannelCloseReject 
+ * response message.
+ * @param call             Handle to the call.
+ * @param rccReject        Pointer to the received reject response message.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooOnReceivedRequestChannelCloseReject
+   (struct OOH323CallData *call, H245RequestChannelCloseReject *rccReject);
+
+/**
+ * This function is used to handle a received RequestChannelCloseAck 
+ * response message.
+ * @param call             Handle to the call.
+ * @param rccAck           Pointer to the received ack response message.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooOnReceivedRequestChannelCloseAck
+   (struct OOH323CallData *call, H245RequestChannelCloseAck *rccAck);
+
+/**
+ * Builds an OLC for faststart with an audio/video capability passed as 
+ * parameter.
+ * @param call             Handle to call for which OLC has to be built.
+ * @param olc              Pointer to an OLC structure which will be populated.
+ * @param epCap            Pointer to the capability which will be used to 
+ *                         build OLC.
+ * @param pctxt            Pointer to an OOCTXT structure which will be used 
+ *                         to allocate additional memory for OLC.
+ * @param dir              Direction of OLC
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooBuildFastStartOLC(struct OOH323CallData *call, 
+                                          H245OpenLogicalChannel *olc, 
+                                          ooH323EpCapability *epCap, 
+                                          OOCTXT*pctxt, int dir);
+
+/**
+ * Prepares a faststart response olc from the olc received in SETUP message.
+ * This function just changes the mediaChannel and mediaControl channel part
+ * of the olc received in SETUP.
+ * @param call             Handle to call for which OLC has to be built.
+ * @param olc              Pointer to an received OLC structure.
+ * @param epCap            Pointer to the capability which will be used for 
+ *                         this channel.
+ * @param pctxt            Pointer to an OOCTXT structure which will be used 
+ *                         to allocate additional memory for OLC.
+ * @param dir              Direction of channel OORX, OOTX etc.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooPrepareFastStartResponseOLC
+   (OOH323CallData *call, H245OpenLogicalChannel *olc, 
+    ooH323EpCapability *epCap, OOCTXT*pctxt, int dir);
+
+/**
+ * This function is used to encode an H245 message and return encoded data
+ * into the buffer passed as a parameter to the function.
+ * @param call            Handle to the call
+ * @param ph245Msg        Handle to the message to be encoded.
+ * @param msgbuf          buffer in which encoded message will be returned.
+ * @param size            Size of the buffer.
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooEncodeH245Message
+(struct OOH323CallData *call, H245Message *ph245Msg, char *msgbuf, int size);
+
+/**
+ * This function is used to send a master-slave determination release message.
+ * @param call             Handle to call, for which MSDRelease message has
+ *                         to be sent.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooSendMasterSlaveDeterminationRelease(struct OOH323CallData * call);
+
+/**
+ * This function is used to send a terminal capability set reject message
+ * to the remote endpoint.
+ * @param call             Handle to the call for which reject message has to 
+ *                         be sent.
+ * @param seqNo            Sequence number of the TCS message to be rejected.
+ * @param cause            Cause for rejecting a TCS message.
+ *
+ * @return                 OO_OK, on success; OO_FAILED, otherwise.
+ */
+int ooSendTerminalCapabilitySetReject
+    (struct OOH323CallData *call, int seqNo, ASN1UINT cause);
+
+/**
+ * This function is used to send a TerminalCapabilitySetRelease message after
+ * capability exchange timer has expired.
+ * @param call            Handle to call for which release message has to be 
+ *                        sent.
+ *
+ * @return                OO_OK, on success; OO_FAILED, on failure.
+ */
+int ooSendTerminalCapabilitySetRelease(struct OOH323CallData * call);
+
+
+/**
+ * This is an helper function used to extract ip address and port info from 
+ * H245TransportAddress structure.
+ * @param call           Handle to associated call.
+ * @param h245Address    Handle to H245TransportAddress structure from which 
+ *                       information has to be extracted.
+ * @param ip             Pointer to buffer in which ip address will be 
+ *                       returned. Make sure that buffer has sufficient length.
+ * @param port           Pointer to integer in which port number will be 
+ *                       returned.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooGetIpPortFromH245TransportAddress
+   (OOH323CallData *call, H245TransportAddress *h245Address, char *ip, 
+    int *port);
+
+/**
+ * This is a callback function for handling an expired master-slave 
+ * determination timer.
+ * @param data             Callback data registered at the time of creation of 
+ *                         the timer.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooMSDTimerExpired(void *data);
+
+/**
+ * This is a callback function for handling an expired capability exchange 
+ * timer.
+ * @param data             Callback data registered at the time of creation of 
+ *                         the timer.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooTCSTimerExpired(void *data);
+
+/**
+ * This is a callback function for handling an expired OpenLogicalChannel 
+ * timer.
+ * @param pdata            Callback data registered at the time of creation of 
+ *                         the timer.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooOpenLogicalChannelTimerExpired(void *pdata);
+
+/**
+ * This is a callback function for handling an expired CloseLogicalChannel 
+ * timer.
+ * @param pdata            Callback data registered at the time of creation of 
+ *                         the timer.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooCloseLogicalChannelTimerExpired(void *pdata);
+
+/**
+ * This is a callback function for handling an expired RequestChannelClose 
+ * timer.
+ * @param pdata            Callback data registered at the time of creation of 
+ *                         the timer.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooRequestChannelCloseTimerExpired(void *pdata);
+
+/**
+ * This is a callback function for handling an expired EndSession timer.
+ * @param pdata            Callback data registered at the time of creation of 
+ *                         the timer.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, otherwise.
+ */
+int ooSessionTimerExpired(void *pdata);
+/** 
+ * @} 
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/ooh323.c b/addons/ooh323c/src/ooh323.c
new file mode 100644
index 000000000..1cefa1d0b
--- /dev/null
+++ b/addons/ooh323c/src/ooh323.c
@@ -0,0 +1,1843 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ootypes.h"
+#include "ooq931.h"
+#include "ootrace.h"
+#include "oochannels.h"
+#include "ooh245.h"
+#include "ooCalls.h"
+#include "printHandler.h"
+#include "ooh323.h"
+#include "ooh323ep.h"
+#include "ooGkClient.h"
+#include "ooTimer.h"
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+
+int ooOnReceivedReleaseComplete(OOH323CallData *call, Q931Message *q931Msg)
+{
+   int ret = OO_OK;
+   H225ReleaseComplete_UUIE * releaseComplete = NULL;
+   ASN1UINT i;
+   DListNode *pNode = NULL;
+   OOTimer *pTimer = NULL;
+   unsigned reasonCode=T_H225ReleaseCompleteReason_undefinedReason;
+   enum Q931CauseValues cause= Q931ErrorInCauseIE;
+
+   if(q931Msg->causeIE)
+   {
+      cause = q931Msg->causeIE->data[1];
+      /* Get rid of the extension bit.For more info, check ooQ931SetCauseIE */
+      cause = cause & 0x7f; 
+      OOTRACEDBGA4("Cause of Release Complete is %x. (%s, %s)\n", cause, 
+                                             call->callType, call->callToken);
+   }
+
+   /* Remove session timer, if active*/
+   for(i = 0; i<call->timerList.count; i++)
+   {
+      pNode = dListFindByIndex(&call->timerList, i);
+      pTimer = (OOTimer*)pNode->data;
+      if(((ooTimerCallback*)pTimer->cbData)->timerType & 
+                                                   OO_SESSION_TIMER)
+      {
+         memFreePtr(call->pctxt, pTimer->cbData);
+         ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+         OOTRACEDBGC3("Deleted Session Timer. (%s, %s)\n", 
+                       call->callType, call->callToken);
+         break;
+      }
+   }
+
+ 
+   if(!q931Msg->userInfo)
+   {
+      OOTRACEERR3("ERROR:No User-User IE in received ReleaseComplete message "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   releaseComplete = q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.releaseComplete;
+   if(!releaseComplete)
+   {
+      OOTRACEWARN3("WARN: ReleaseComplete UUIE not found in received "
+                  "ReleaseComplete message - %s "
+                  "%s\n", call->callType, call->callToken);
+   }
+   else{
+
+      if(releaseComplete->m.reasonPresent)
+      {
+         OOTRACEINFO4("Release complete reason code %d. (%s, %s)\n", 
+                   releaseComplete->reason.t, call->callType, call->callToken);
+         reasonCode = releaseComplete->reason.t;
+      }
+   }
+
+   if(call->callEndReason == OO_REASON_UNKNOWN)
+      call->callEndReason = ooGetCallClearReasonFromCauseAndReasonCode(cause, 
+                                                                   reasonCode);
+#if 0
+   if (q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent &&
+       q931Msg->userInfo->h323_uu_pdu.h245Tunneling          &&
+       OO_TESTFLAG (call->flags, OO_M_TUNNELING) )
+   {
+      OOTRACEDBGB3("Handling tunneled messages in ReleaseComplete. (%s, %s)\n",
+                   call->callType, call->callToken);
+      ret = ooHandleTunneledH245Messages
+                    (call, &q931Msg->userInfo->h323_uu_pdu);
+      OOTRACEDBGB3("Finished handling tunneled messages in ReleaseComplete."
+                   " (%s, %s)\n", call->callType, call->callToken);
+   }
+#endif
+   if(call->h245SessionState != OO_H245SESSION_IDLE && 
+      call->h245SessionState != OO_H245SESSION_CLOSED)
+   {
+      ooCloseH245Connection(call);
+   }
+
+   if(call->callState != OO_CALL_CLEAR_RELEASESENT)
+   {
+      if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK))
+      {
+         if(gH323ep.gkClient->state == GkClientRegistered){
+            OOTRACEDBGA3("Sending DRQ after received ReleaseComplete."
+                         "(%s, %s)\n", call->callType, call->callToken);
+            ooGkClientSendDisengageRequest(gH323ep.gkClient, call);
+         }
+      }
+   }
+   call->callState = OO_CALL_CLEARED;
+
+   return ret;
+}
+
+int ooOnReceivedSetup(OOH323CallData *call, Q931Message *q931Msg)
+{
+   H225Setup_UUIE *setup=NULL;
+   int i=0, ret=0;
+   H245OpenLogicalChannel* olc;
+   ASN1OCTET msgbuf[MAXMSGLEN];
+   H225TransportAddress_ipAddress_ip *ip = NULL;
+   Q931InformationElement* pDisplayIE=NULL;
+   OOAliases *pAlias=NULL;
+
+   call->callReference = q931Msg->callReference;
+ 
+   if(!q931Msg->userInfo)
+   {
+      OOTRACEERR3("ERROR:No User-User IE in received SETUP message (%s, %s)\n",
+                  call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   setup = q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.setup;
+   if(!setup)
+   {
+      OOTRACEERR3("Error: Setup UUIE not found in received setup message - %s "
+                  "%s\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   memcpy(call->callIdentifier.guid.data, setup->callIdentifier.guid.data, 
+          setup->callIdentifier.guid.numocts);
+   call->callIdentifier.guid.numocts = setup->callIdentifier.guid.numocts;
+   
+   memcpy(call->confIdentifier.data, setup->conferenceID.data,
+          setup->conferenceID.numocts);
+   call->confIdentifier.numocts = setup->conferenceID.numocts;
+
+   /* check for display ie */
+   pDisplayIE = ooQ931GetIE(q931Msg, Q931DisplayIE);
+   if(pDisplayIE)
+   {
+      call->remoteDisplayName = (ASN1OCTET*) memAlloc(call->pctxt, 
+                                 pDisplayIE->length*sizeof(ASN1OCTET)+1);
+      strcpy(call->remoteDisplayName, pDisplayIE->data);
+   }
+   /*Extract Remote Aliases, if present*/
+   if(setup->m.sourceAddressPresent)
+   {
+      if(setup->sourceAddress.count>0)
+      {
+         ooH323RetrieveAliases(call, &setup->sourceAddress, 
+                                                       &call->remoteAliases);
+         pAlias = call->remoteAliases;
+         while(pAlias)
+         {
+            if(pAlias->type ==  T_H225AliasAddress_dialedDigits)
+            {
+              if(!call->callingPartyNumber)
+              {
+                 call->callingPartyNumber = (char*)memAlloc(call->pctxt,
+                                                    strlen(pAlias->value)*+1);
+                 if(call->callingPartyNumber)
+                 {
+                     strcpy(call->callingPartyNumber, pAlias->value);
+                 }
+              }
+              break;
+           }
+           pAlias = pAlias->next;
+         }
+      }
+   }
+   /* Extract, aliases used for us, if present. Also,
+      Populate calledPartyNumber from dialedDigits, if not yet populated using
+      calledPartyNumber Q931 IE. 
+   */      
+   if(setup->m.destinationAddressPresent)
+   {
+      if(setup->destinationAddress.count>0)
+      {
+         ooH323RetrieveAliases(call, &setup->destinationAddress, 
+                                                       &call->ourAliases);
+         pAlias = call->ourAliases;
+         while(pAlias)
+         {
+            if(pAlias->type == T_H225AliasAddress_dialedDigits)
+            {
+              if(!call->calledPartyNumber)
+              {
+                 call->calledPartyNumber = (char*)memAlloc(call->pctxt,
+                                                    strlen(pAlias->value)*+1);
+                 if(call->calledPartyNumber)
+                 {
+                    strcpy(call->calledPartyNumber, pAlias->value);
+                 }
+              }
+              break;
+            }
+            pAlias = pAlias->next; 
+         }
+      }
+   }
+
+   /* Check for tunneling */
+   if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent)
+   {
+      /* Tunneling enabled only when tunneling is set to true and h245
+         address is absent. In the presence of H.245 address in received
+         SETUP message, tunneling is disabled, irrespective of tunneling
+         flag in the setup message*/
+      if(q931Msg->userInfo->h323_uu_pdu.h245Tunneling &&
+         !setup->m.h245AddressPresent)
+      {
+         if(OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING))
+         {
+            OO_SETFLAG (call->flags, OO_M_TUNNELING);
+            OOTRACEINFO3("Call has tunneling active (%s,%s)\n", call->callType,
+                          call->callToken);
+         }
+         else
+            OOTRACEINFO3("ERROR:Remote endpoint wants to use h245Tunneling, "
+                        "local endpoint has it disabled (%s,%s)\n",
+                        call->callType, call->callToken);
+      }
+      else {
+         if(OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING))
+         {
+            OOTRACEINFO3("Tunneling disabled by remote endpoint. (%s, %s)\n",
+                         call->callType, call->callToken);
+         }
+         OO_CLRFLAG (call->flags, OO_M_TUNNELING);
+      }
+   }
+   else {
+      if(OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING))
+      {
+         OOTRACEINFO3("Tunneling disabled by remote endpoint. (%s, %s)\n",
+                       call->callType, call->callToken);
+      }
+      OO_CLRFLAG (call->flags, OO_M_TUNNELING);
+   }
+   
+   /* Extract Remote IP address */
+   if(!setup->m.sourceCallSignalAddressPresent)
+   {
+      OOTRACEWARN3("WARNING:Missing source call signal address in received "
+                   "setup (%s, %s)\n", call->callType, call->callToken);
+   }
+   else{
+
+      if(setup->sourceCallSignalAddress.t != T_H225TransportAddress_ipAddress)
+      {
+         OOTRACEERR3("ERROR: Source call signalling address type not ip "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+
+      ip = &setup->sourceCallSignalAddress.u.ipAddress->ip;
+      sprintf(call->remoteIP, "%d.%d.%d.%d", ip->data[0], ip->data[1], 
+                                             ip->data[2], ip->data[3]);
+      call->remotePort =  setup->sourceCallSignalAddress.u.ipAddress->port;
+   }
+   
+   /* check for fast start */
+   
+   if(setup->m.fastStartPresent)
+   {
+      if(!OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART))
+      {
+         OOTRACEINFO3("Local endpoint does not support fastStart. Ignoring "
+                     "fastStart. (%s, %s)\n", call->callType, call->callToken);
+         OO_CLRFLAG (call->flags, OO_M_FASTSTART);
+      }
+      else if(setup->fastStart.n == 0)
+      {
+         OOTRACEINFO3("Empty faststart element received. Ignoring fast start. "
+                      "(%s, %s)\n", call->callType, call->callToken);
+         OO_CLRFLAG (call->flags, OO_M_FASTSTART);
+      }
+      else{
+         OO_SETFLAG (call->flags, OO_M_FASTSTART);
+         OOTRACEINFO3("FastStart enabled for call(%s, %s)\n", call->callType,
+                       call->callToken);
+      }
+   }
+
+   if (OO_TESTFLAG (call->flags, OO_M_FASTSTART))
+   {
+      /* For printing the decoded message to log, initialize handler. */
+      initializePrintHandler(&printHandler, "FastStart Elements");
+
+      /* Set print handler */
+      setEventHandler (call->pctxt, &printHandler);
+
+      for(i=0; i<(int)setup->fastStart.n; i++)
+      {
+         olc = NULL;
+         /*         memset(msgbuf, 0, sizeof(msgbuf));*/
+         olc = (H245OpenLogicalChannel*)memAlloc(call->pctxt, 
+                                              sizeof(H245OpenLogicalChannel));
+         if(!olc)
+         {
+            OOTRACEERR3("ERROR:Memory - ooOnReceivedSetup - olc (%s, %s)\n", 
+                        call->callType, call->callToken);
+            /*Mark call for clearing */
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_LOCAL_CLEARED;
+               call->callState = OO_CALL_CLEAR;
+            }
+            return OO_FAILED;
+         }
+         memset(olc, 0, sizeof(H245OpenLogicalChannel));
+         memcpy(msgbuf, setup->fastStart.elem[i].data, 
+                setup->fastStart.elem[i].numocts);
+
+         setPERBuffer(call->pctxt, msgbuf, 
+                      setup->fastStart.elem[i].numocts, 1);
+         ret = asn1PD_H245OpenLogicalChannel(call->pctxt, olc);
+         if(ret != ASN_OK)
+         {
+            OOTRACEERR3("ERROR:Failed to decode fast start olc element "
+                        "(%s, %s)\n", call->callType, call->callToken);
+            /* Mark call for clearing */
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_INVALIDMESSAGE;
+               call->callState = OO_CALL_CLEAR;
+            }
+            return OO_FAILED;
+         }
+         /* For now, just add decoded fast start elemts to list. This list
+            will be processed at the time of sending CONNECT message. */
+         dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc);
+      }
+      finishPrint();
+      removeEventHandler(call->pctxt);
+   }
+
+   return OO_OK;
+}
+
+
+
+int ooOnReceivedCallProceeding(OOH323CallData *call, Q931Message *q931Msg)
+{
+   H225CallProceeding_UUIE *callProceeding=NULL;
+   H245OpenLogicalChannel* olc;
+   ASN1OCTET msgbuf[MAXMSGLEN];
+   ooLogicalChannel * pChannel = NULL;
+   H245H2250LogicalChannelParameters * h2250lcp = NULL;  
+   int i=0, ret=0;
+
+   if(!q931Msg->userInfo)
+   {
+      OOTRACEERR3("ERROR:No User-User IE in received CallProceeding message."
+                  " (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   callProceeding = 
+             q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.callProceeding;
+   if(callProceeding == NULL)
+   {
+      OOTRACEERR3("Error: Received CallProceeding message does not have "
+                  "CallProceeding UUIE (%s, %s)\n", call->callType, 
+                  call->callToken);
+      /* Mark call for clearing */
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callEndReason = OO_REASON_INVALIDMESSAGE;
+         call->callState = OO_CALL_CLEAR;
+      }
+      return OO_FAILED;
+   }
+
+   /* Handle fast-start */
+   if(OO_TESTFLAG (call->flags, OO_M_FASTSTART))
+   {
+      if(callProceeding->m.fastStartPresent)
+      {
+         /* For printing the decoded message to log, initialize handler. */
+         initializePrintHandler(&printHandler, "FastStart Elements");
+
+         /* Set print handler */
+         setEventHandler (call->pctxt, &printHandler);
+
+         for(i=0; i<(int)callProceeding->fastStart.n; i++)
+         {
+            olc = NULL;
+
+            olc = (H245OpenLogicalChannel*)memAlloc(call->pctxt, 
+                                              sizeof(H245OpenLogicalChannel));
+            if(!olc)
+            {
+               OOTRACEERR3("ERROR:Memory - ooOnReceivedCallProceeding - olc"
+                           "(%s, %s)\n", call->callType, call->callToken);
+               /*Mark call for clearing */
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_LOCAL_CLEARED;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+            memset(olc, 0, sizeof(H245OpenLogicalChannel));
+            memcpy(msgbuf, callProceeding->fastStart.elem[i].data, 
+                                    callProceeding->fastStart.elem[i].numocts);
+            setPERBuffer(call->pctxt, msgbuf, 
+                         callProceeding->fastStart.elem[i].numocts, 1);
+            ret = asn1PD_H245OpenLogicalChannel(call->pctxt, olc);
+            if(ret != ASN_OK)
+            {
+               OOTRACEERR3("ERROR:Failed to decode fast start olc element "
+                           "(%s, %s)\n", call->callType, call->callToken);
+               /* Mark call for clearing */
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_INVALIDMESSAGE;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+
+            dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc);
+
+            pChannel = ooFindLogicalChannelByOLC(call, olc);
+            if(!pChannel)
+            {
+               OOTRACEERR4("ERROR: Logical Channel %d not found, fast start. "
+                           "(%s, %s)\n",
+                            olc->forwardLogicalChannelNumber, call->callType, 
+                            call->callToken);
+               return OO_FAILED;
+            }
+            if(pChannel->channelNo != olc->forwardLogicalChannelNumber)
+            {
+               OOTRACEINFO5("Remote endpoint changed forwardLogicalChannel"
+                            "Number from %d to %d (%s, %s)\n", 
+                            pChannel->channelNo, 
+                            olc->forwardLogicalChannelNumber, call->callType, 
+                            call->callToken);
+               pChannel->channelNo = olc->forwardLogicalChannelNumber;
+            }
+            if(!strcmp(pChannel->dir, "transmit"))
+            {
+               if(olc->forwardLogicalChannelParameters.multiplexParameters.t !=
+                  T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
+               {
+                  OOTRACEERR4("ERROR:Unknown multiplex parameter type for "
+                              "channel %d (%s, %s)\n", 
+                              olc->forwardLogicalChannelNumber, call->callType,
+                              call->callToken);
+                  continue;
+               }
+            
+               /* Extract the remote media endpoint address */
+               h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;
+               if(!h2250lcp)
+               {
+                  OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
+                              "forward Logical Channel Parameters found. "
+                              "(%s, %s)\n", call->callType, call->callToken);
+                  return OO_FAILED;
+               }
+               if(!h2250lcp->m.mediaChannelPresent)
+               {
+                  OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
+                              "reverse media channel information found."
+                              "(%s, %s)\n", call->callType, call->callToken);
+                  return OO_FAILED;
+               }
+               ret = ooGetIpPortFromH245TransportAddress(call, 
+                                   &h2250lcp->mediaChannel, pChannel->remoteIP,
+                                   &pChannel->remoteMediaPort);
+               
+               if(ret != OO_OK)
+               {
+                  OOTRACEERR3("ERROR:Unsupported media channel address type "
+                              "(%s, %s)\n", call->callType, call->callToken);
+                  return OO_FAILED;
+               }
+       
+               if(!pChannel->chanCap->startTransmitChannel)
+               {
+                  OOTRACEERR3("ERROR:No callback registered to start transmit "
+                              "channel (%s, %s)\n",call->callType, 
+                              call->callToken);
+                  return OO_FAILED;
+               }
+               pChannel->chanCap->startTransmitChannel(call, pChannel);
+            }
+            /* Mark the current channel as established and close all other 
+               logical channels with same session id and in same direction.
+            */
+            ooOnLogicalChannelEstablished(call, pChannel);
+         }
+         finishPrint();
+         removeEventHandler(call->pctxt);
+         OO_SETFLAG(call->flags, OO_M_FASTSTARTANSWERED);
+      }
+      
+   }
+
+   /* Retrieve the H.245 control channel address from the connect msg */
+   if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent &&
+      q931Msg->userInfo->h323_uu_pdu.h245Tunneling &&
+      callProceeding->m.h245AddressPresent) {
+      OOTRACEINFO3("Tunneling and h245address provided."
+                   "Using Tunneling for H.245 messages (%s, %s)\n", 
+                   call->callType, call->callToken);
+   }
+   else if(callProceeding->m.h245AddressPresent)
+   {
+      if (OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+      {
+         OO_CLRFLAG (call->flags, OO_M_TUNNELING);
+         OOTRACEINFO3("Tunneling is disabled for call as H245 address is "
+                      "provided in callProceeding message (%s, %s)\n", 
+                      call->callType, call->callToken);
+      }
+      ret = ooH323GetIpPortFromH225TransportAddress(call, 
+                                  &callProceeding->h245Address, call->remoteIP,
+                                  &call->remoteH245Port);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR3("Error: Unknown H245 address type in received "
+                     "CallProceeding message (%s, %s)", call->callType, 
+                     call->callToken);
+         /* Mark call for clearing */
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_INVALIDMESSAGE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+   }
+   return OO_OK;
+}
+
+
+int ooOnReceivedAlerting(OOH323CallData *call, Q931Message *q931Msg)
+{
+   H225Alerting_UUIE *alerting=NULL;
+   H245OpenLogicalChannel* olc;
+   ASN1OCTET msgbuf[MAXMSGLEN];
+   ooLogicalChannel * pChannel = NULL;
+   H245H2250LogicalChannelParameters * h2250lcp = NULL;  
+   int i=0, ret=0;
+
+
+   if(!q931Msg->userInfo)
+   {
+      OOTRACEERR3("ERROR:No User-User IE in received Alerting message."
+                  " (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   alerting = q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.alerting;
+   if(alerting == NULL)
+   {
+      OOTRACEERR3("Error: Received Alerting message does not have "
+                  "alerting UUIE (%s, %s)\n", call->callType, 
+                  call->callToken);
+      /* Mark call for clearing */
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callEndReason = OO_REASON_INVALIDMESSAGE;
+         call->callState = OO_CALL_CLEAR;
+      }
+      return OO_FAILED;
+   }
+   /*Handle fast-start */
+   if(OO_TESTFLAG (call->flags, OO_M_FASTSTART) &&
+      !OO_TESTFLAG(call->flags, OO_M_FASTSTARTANSWERED))
+   {
+      if(alerting->m.fastStartPresent)
+      {
+         /* For printing the decoded message to log, initialize handler. */
+         initializePrintHandler(&printHandler, "FastStart Elements");
+
+         /* Set print handler */
+         setEventHandler (call->pctxt, &printHandler);
+
+         for(i=0; i<(int)alerting->fastStart.n; i++)
+         {
+            olc = NULL;
+
+            olc = (H245OpenLogicalChannel*)memAlloc(call->pctxt, 
+                                              sizeof(H245OpenLogicalChannel));
+            if(!olc)
+            {
+               OOTRACEERR3("ERROR:Memory - ooOnReceivedAlerting - olc"
+                           "(%s, %s)\n", call->callType, call->callToken);
+               /*Mark call for clearing */
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_LOCAL_CLEARED;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+            memset(olc, 0, sizeof(H245OpenLogicalChannel));
+            memcpy(msgbuf, alerting->fastStart.elem[i].data, 
+                                    alerting->fastStart.elem[i].numocts);
+            setPERBuffer(call->pctxt, msgbuf, 
+                         alerting->fastStart.elem[i].numocts, 1);
+            ret = asn1PD_H245OpenLogicalChannel(call->pctxt, olc);
+            if(ret != ASN_OK)
+            {
+               OOTRACEERR3("ERROR:Failed to decode fast start olc element "
+                           "(%s, %s)\n", call->callType, call->callToken);
+               /* Mark call for clearing */
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_INVALIDMESSAGE;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+
+            dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc);
+
+            pChannel = ooFindLogicalChannelByOLC(call, olc);
+            if(!pChannel)
+            {
+               OOTRACEERR4("ERROR: Logical Channel %d not found, fast start. "
+                           "(%s, %s)\n",
+                            olc->forwardLogicalChannelNumber, call->callType, 
+                            call->callToken);
+               return OO_FAILED;
+            }
+            if(pChannel->channelNo != olc->forwardLogicalChannelNumber)
+            {
+               OOTRACEINFO5("Remote endpoint changed forwardLogicalChannel"
+                            "Number from %d to %d (%s, %s)\n", 
+                            pChannel->channelNo, 
+                            olc->forwardLogicalChannelNumber, call->callType, 
+                            call->callToken);
+               pChannel->channelNo = olc->forwardLogicalChannelNumber;
+            }
+            if(!strcmp(pChannel->dir, "transmit"))
+            {
+               if(olc->forwardLogicalChannelParameters.multiplexParameters.t !=
+                  T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
+               {
+                  OOTRACEERR4("ERROR:Unknown multiplex parameter type for "
+                              "channel %d (%s, %s)\n", 
+                              olc->forwardLogicalChannelNumber, call->callType,
+                              call->callToken);
+                  continue;
+               }
+            
+               /* Extract the remote media endpoint address */
+               h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;
+               if(!h2250lcp)
+               {
+                  OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
+                              "forward Logical Channel Parameters found. "
+                              "(%s, %s)\n", call->callType, call->callToken);
+                  return OO_FAILED;
+               }
+               if(!h2250lcp->m.mediaChannelPresent)
+               {
+                  OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
+                              "reverse media channel information found."
+                              "(%s, %s)\n", call->callType, call->callToken);
+                  return OO_FAILED;
+               }
+               ret = ooGetIpPortFromH245TransportAddress(call, 
+                                   &h2250lcp->mediaChannel, pChannel->remoteIP,
+                                   &pChannel->remoteMediaPort);
+               
+               if(ret != OO_OK)
+               {
+                  OOTRACEERR3("ERROR:Unsupported media channel address type "
+                              "(%s, %s)\n", call->callType, call->callToken);
+                  return OO_FAILED;
+               }
+       
+               if(!pChannel->chanCap->startTransmitChannel)
+               {
+                  OOTRACEERR3("ERROR:No callback registered to start transmit "
+                              "channel (%s, %s)\n",call->callType, 
+                              call->callToken);
+                  return OO_FAILED;
+               }
+               pChannel->chanCap->startTransmitChannel(call, pChannel);
+            }
+            /* Mark the current channel as established and close all other 
+               logical channels with same session id and in same direction.
+            */
+            ooOnLogicalChannelEstablished(call, pChannel);
+         }
+         finishPrint();
+         removeEventHandler(call->pctxt);
+         OO_SETFLAG(call->flags, OO_M_FASTSTARTANSWERED);
+      }
+      
+   }
+
+   /* Retrieve the H.245 control channel address from the connect msg */
+   if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent &&
+      q931Msg->userInfo->h323_uu_pdu.h245Tunneling &&
+      alerting->m.h245AddressPresent) {
+      OOTRACEINFO3("Tunneling and h245address provided."
+                   "Giving preference to Tunneling (%s, %s)\n", 
+                   call->callType, call->callToken);
+   }
+   else if(alerting->m.h245AddressPresent)
+   {
+      if (OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+      {
+         OO_CLRFLAG (call->flags, OO_M_TUNNELING);
+         OOTRACEINFO3("Tunneling is disabled for call as H245 address is "
+                      "provided in Alerting message (%s, %s)\n", 
+                      call->callType, call->callToken);
+      }
+      ret = ooH323GetIpPortFromH225TransportAddress(call, 
+                                  &alerting->h245Address, call->remoteIP,
+                                  &call->remoteH245Port);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR3("Error: Unknown H245 address type in received "
+                     "Alerting message (%s, %s)", call->callType, 
+                     call->callToken);
+         /* Mark call for clearing */
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_INVALIDMESSAGE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+   }
+   return OO_OK;
+}
+   
+
+int ooOnReceivedSignalConnect(OOH323CallData* call, Q931Message *q931Msg)
+{
+   int ret, i;
+   H225Connect_UUIE *connect;
+   H245OpenLogicalChannel* olc;
+   ASN1OCTET msgbuf[MAXMSGLEN];
+   ooLogicalChannel * pChannel = NULL;
+   H245H2250LogicalChannelParameters * h2250lcp = NULL;  
+
+   if(!q931Msg->userInfo)
+   {
+      OOTRACEERR3("Error: UUIE not found in received H.225 Connect message"
+                  " (%s, %s)\n", call->callType, call->callToken);
+      /* Mark call for clearing */
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callEndReason = OO_REASON_INVALIDMESSAGE;
+         call->callState = OO_CALL_CLEAR;
+      }
+      return OO_FAILED;
+   }
+   /* Retrieve the connect message from the user-user IE & Q.931 header */
+   connect = q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.connect;
+   if(connect == NULL)
+   {
+      OOTRACEERR3("Error: Received Connect message does not have Connect UUIE"
+                  " (%s, %s)\n", call->callType, call->callToken);
+      /* Mark call for clearing */
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callEndReason = OO_REASON_INVALIDMESSAGE;
+         call->callState = OO_CALL_CLEAR;
+      }
+      return OO_FAILED;
+   }
+
+   /*Handle fast-start */
+   if(OO_TESTFLAG (call->flags, OO_M_FASTSTART) && 
+      !OO_TESTFLAG (call->flags, OO_M_FASTSTARTANSWERED))
+   {
+      if(!connect->m.fastStartPresent)
+      {
+         OOTRACEINFO3("Remote endpoint has rejected fastStart. (%s, %s)\n",
+                      call->callType, call->callToken);
+         /* Clear all channels we might have created */
+         ooClearAllLogicalChannels(call);
+         OO_CLRFLAG (call->flags, OO_M_FASTSTART);
+      }
+   }
+
+   if (connect->m.fastStartPresent && 
+       !OO_TESTFLAG(call->flags, OO_M_FASTSTARTANSWERED))
+   {
+      /* For printing the decoded message to log, initialize handler. */
+      initializePrintHandler(&printHandler, "FastStart Elements");
+
+      /* Set print handler */
+      setEventHandler (call->pctxt, &printHandler);
+
+      for(i=0; i<(int)connect->fastStart.n; i++)
+      {
+         olc = NULL;
+         /* memset(msgbuf, 0, sizeof(msgbuf));*/
+         olc = (H245OpenLogicalChannel*)memAlloc(call->pctxt, 
+                                              sizeof(H245OpenLogicalChannel));
+         if(!olc)
+         {
+            OOTRACEERR3("ERROR:Memory - ooOnReceivedSignalConnect - olc"
+                        "(%s, %s)\n", call->callType, call->callToken);
+            /*Mark call for clearing */
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_LOCAL_CLEARED;
+               call->callState = OO_CALL_CLEAR;
+            }
+            finishPrint();
+            removeEventHandler(call->pctxt);
+            return OO_FAILED;
+         }
+         memset(olc, 0, sizeof(H245OpenLogicalChannel));
+         memcpy(msgbuf, connect->fastStart.elem[i].data, 
+                                           connect->fastStart.elem[i].numocts);
+         setPERBuffer(call->pctxt, msgbuf, 
+                      connect->fastStart.elem[i].numocts, 1);
+         ret = asn1PD_H245OpenLogicalChannel(call->pctxt, olc);
+         if(ret != ASN_OK)
+         {
+            OOTRACEERR3("ERROR:Failed to decode fast start olc element "
+                        "(%s, %s)\n", call->callType, call->callToken);
+            /* Mark call for clearing */
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callEndReason = OO_REASON_INVALIDMESSAGE;
+               call->callState = OO_CALL_CLEAR;
+            }
+            finishPrint();
+            removeEventHandler(call->pctxt);
+            return OO_FAILED;
+         }
+
+         dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc);
+
+         pChannel = ooFindLogicalChannelByOLC(call, olc);
+         if(!pChannel)
+         {
+            OOTRACEERR4("ERROR: Logical Channel %d not found, fasts start "
+                        "answered. (%s, %s)\n",
+                         olc->forwardLogicalChannelNumber, call->callType, 
+                         call->callToken);
+            finishPrint();
+            removeEventHandler(call->pctxt);
+            return OO_FAILED;
+         }
+         if(pChannel->channelNo != olc->forwardLogicalChannelNumber)
+         {
+            OOTRACEINFO5("Remote endpoint changed forwardLogicalChannelNumber"
+                         "from %d to %d (%s, %s)\n", pChannel->channelNo,
+                          olc->forwardLogicalChannelNumber, call->callType, 
+                          call->callToken);
+            pChannel->channelNo = olc->forwardLogicalChannelNumber;
+         }
+         if(!strcmp(pChannel->dir, "transmit"))
+         {
+            if(olc->forwardLogicalChannelParameters.multiplexParameters.t != 
+               T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
+            {
+               OOTRACEERR4("ERROR:Unknown multiplex parameter type for channel"
+                           " %d (%s, %s)\n", olc->forwardLogicalChannelNumber, 
+                           call->callType, call->callToken);
+               continue;
+            }
+            
+            /* Extract the remote media endpoint address */
+            h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;
+            if(!h2250lcp)
+            {
+               OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
+                           "forward Logical Channel Parameters found. (%s, %s)"
+                           "\n", call->callType, call->callToken);
+               finishPrint();
+               removeEventHandler(call->pctxt);
+               return OO_FAILED;
+            }
+            if(!h2250lcp->m.mediaChannelPresent)
+            {
+               OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
+                           "reverse media channel information found. (%s, %s)"
+                           "\n", call->callType, call->callToken);
+               finishPrint();
+               removeEventHandler(call->pctxt);
+               return OO_FAILED;
+            }
+
+            ret = ooGetIpPortFromH245TransportAddress(call, 
+                                   &h2250lcp->mediaChannel, pChannel->remoteIP,
+                                   &pChannel->remoteMediaPort);
+            if(ret != OO_OK)
+            {
+               OOTRACEERR3("ERROR:Unsupported media channel address type "
+                           "(%s, %s)\n", call->callType, call->callToken);
+               finishPrint();
+               removeEventHandler(call->pctxt);
+               return OO_FAILED;
+            }
+            if(!pChannel->chanCap->startTransmitChannel)
+            {
+               OOTRACEERR3("ERROR:No callback registered to start transmit "
+                         "channel (%s, %s)\n",call->callType, call->callToken);
+               finishPrint();
+               removeEventHandler(call->pctxt);
+               return OO_FAILED;
+            }
+            pChannel->chanCap->startTransmitChannel(call, pChannel);
+         }
+         /* Mark the current channel as established and close all other 
+            logical channels with same session id and in same direction.
+         */
+         ooOnLogicalChannelEstablished(call, pChannel);
+      }
+      finishPrint();
+      removeEventHandler(call->pctxt);
+      OO_SETFLAG(call->flags, OO_M_FASTSTARTANSWERED);
+   }
+
+   /* Retrieve the H.245 control channel address from the CONNECT msg */
+   if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent &&
+      q931Msg->userInfo->h323_uu_pdu.h245Tunneling &&
+      connect->m.h245AddressPresent) {
+      OOTRACEINFO3("Tunneling and h245address provided."
+                   "Giving preference to Tunneling (%s, %s)\n", 
+                   call->callType, call->callToken);
+   }
+   else if(connect->m.h245AddressPresent)
+   {
+      if (OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+      {
+         OO_CLRFLAG (call->flags, OO_M_TUNNELING);
+         OOTRACEINFO3("Tunneling is disabled for call as H245 address is "
+                      "provided in connect message (%s, %s)\n", 
+                      call->callType, call->callToken);
+      }
+      ret = ooH323GetIpPortFromH225TransportAddress(call, 
+                 &connect->h245Address, call->remoteIP, &call->remoteH245Port);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR3("Error: Unknown H245 address type in received Connect "
+                     "message (%s, %s)", call->callType, call->callToken);
+         /* Mark call for clearing */
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_INVALIDMESSAGE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+   }
+
+   if(call->remoteH245Port != 0)
+   {
+       /* Create an H.245 connection. 
+      */
+      if(ooCreateH245Connection(call)== OO_FAILED)
+      {
+         OOTRACEERR3("Error: H.245 channel creation failed (%s, %s)\n", 
+                     call->callType, call->callToken);
+
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
+            call->callState = OO_CALL_CLEAR;
+         }
+         return OO_FAILED;
+      }
+   }
+
+   if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent)
+   {
+      if (!q931Msg->userInfo->h323_uu_pdu.h245Tunneling)
+      {
+         if (OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         {
+            OO_CLRFLAG (call->flags, OO_M_TUNNELING);
+            OOTRACEINFO3("Tunneling is disabled by remote endpoint.(%s, %s)\n",
+                          call->callType, call->callToken);
+         }
+      }
+   }
+   if (OO_TESTFLAG(call->flags, OO_M_TUNNELING))
+   {
+      OOTRACEDBGB3("Handling tunneled messages in CONNECT. (%s, %s)\n",
+                    call->callType, call->callToken);
+      ret = ooHandleTunneledH245Messages
+         (call, &q931Msg->userInfo->h323_uu_pdu);
+      OOTRACEDBGB3("Finished tunneled messages in Connect. (%s, %s)\n",
+                    call->callType, call->callToken);
+
+      /*
+        Send TCS as call established and no capability exchange has yet 
+        started. This will be true only when separate h245 connection is not
+        established and tunneling is being used.
+      */
+      if(call->localTermCapState == OO_LocalTermCapExchange_Idle)
+      {
+         /*Start terminal capability exchange and master slave determination */
+         ret = ooSendTermCapMsg(call);
+         if(ret != OO_OK)
+         {
+            OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n",
+                         call->callType, call->callToken);
+            return ret;
+         }
+      }
+      if(call->masterSlaveState == OO_MasterSlave_Idle)
+      {
+         ret = ooSendMasterSlaveDetermination(call);
+         if(ret != OO_OK)
+         {
+            OOTRACEERR3("ERROR:Sending Master-slave determination message "
+                     "(%s, %s)\n", call->callType, call->callToken);
+            return ret;
+         }   
+      }
+
+   }
+   return OO_OK;  
+}
+
+int ooHandleH2250Message(OOH323CallData *call, Q931Message *q931Msg)
+{
+   int ret=OO_OK;
+   ASN1UINT i;
+   DListNode *pNode = NULL;
+   OOTimer *pTimer=NULL;
+   int type = q931Msg->messageType;
+   switch(type)
+   {
+      case Q931SetupMsg: /* SETUP message is received */
+         OOTRACEINFO3("Received SETUP message (%s, %s)\n", call->callType,
+                       call->callToken);
+         ooOnReceivedSetup(call, q931Msg);
+
+         /* H225 message callback */
+         if(gH323ep.h225Callbacks.onReceivedSetup)
+            gH323ep.h225Callbacks.onReceivedSetup(call, q931Msg);
+
+         /* Free up the mem used by the received message, as it's processing 
+            is done. 
+         */
+         ooFreeQ931Message(q931Msg);
+         
+         ooSendCallProceeding(call);/* Send call proceeding message*/
+         
+         /* DISABLEGK is used to selectively disable gatekeeper use. For 
+            incoming calls DISABLEGK can be set in onReceivedSetup callback by 
+            application. Very useful in pbx applications where gk is used only 
+            when call is to or from outside pbx domian
+         */
+         if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK))
+         {
+            if(gH323ep.gkClient->state == GkClientRegistered)
+            {
+               ret = ooGkClientSendAdmissionRequest(gH323ep.gkClient, call, 
+                                                    FALSE);
+               call->callState = OO_CALL_WAITING_ADMISSION;
+            }
+            else{
+               /* TODO: Should send Release complete with reject reason */
+               OOTRACEERR1("Error:Ignoring incoming call as not yet"
+                           "registered with Gk\n");
+            }
+         }
+         else {
+            ret = ooH323CallAdmitted (call);
+         }
+         break;
+
+
+      case Q931CallProceedingMsg: /* CALL PROCEEDING message is received */
+         OOTRACEINFO3("H.225 Call Proceeding message received (%s, %s)\n",
+                      call->callType, call->callToken);
+         ooOnReceivedCallProceeding(call, q931Msg);
+
+         ooFreeQ931Message(q931Msg);
+         break;
+
+
+      case Q931AlertingMsg:/* ALERTING message received */
+         OOTRACEINFO3("H.225 Alerting message received (%s, %s)\n", 
+                      call->callType, call->callToken);
+
+         ooOnReceivedAlerting(call, q931Msg);
+
+         if(gH323ep.h323Callbacks.onAlerting && call->callState<OO_CALL_CLEAR)
+            gH323ep.h323Callbacks.onAlerting(call);
+         ooFreeQ931Message(q931Msg);
+         break;
+
+
+      case Q931ConnectMsg:/* CONNECT message received */
+         OOTRACEINFO3("H.225 Connect message received (%s, %s)\n",
+                      call->callType, call->callToken);
+
+         /* Disable call establishment timer */
+         for(i = 0; i<call->timerList.count; i++)
+         {
+            pNode = dListFindByIndex(&call->timerList, i);
+            pTimer = (OOTimer*)pNode->data;
+            if(((ooTimerCallback*)pTimer->cbData)->timerType & 
+                                                         OO_CALLESTB_TIMER)
+            {
+               memFreePtr(call->pctxt, pTimer->cbData);
+               ooTimerDelete(call->pctxt, &call->timerList, pTimer);
+               OOTRACEDBGC3("Deleted CallESTB timer. (%s, %s)\n", 
+                                              call->callType, call->callToken);
+               break;
+            }
+         }
+         ret = ooOnReceivedSignalConnect(call, q931Msg);
+         if(ret != OO_OK)
+            OOTRACEERR3("Error:Invalid Connect message received. (%s, %s)\n",
+                        call->callType, call->callToken);
+         else{
+             /* H225 message callback */
+            if(gH323ep.h225Callbacks.onReceivedConnect)
+               gH323ep.h225Callbacks.onReceivedConnect(call, q931Msg);
+
+            if(gH323ep.h323Callbacks.onCallEstablished)
+               gH323ep.h323Callbacks.onCallEstablished(call);
+         }
+         ooFreeQ931Message(q931Msg);
+         break;
+      case Q931InformationMsg:
+         OOTRACEINFO3("H.225 Information msg received (%s, %s)\n",
+                       call->callType, call->callToken);
+         ooFreeQ931Message(q931Msg);
+         break;
+
+
+      case Q931ReleaseCompleteMsg:/* RELEASE COMPLETE message received */
+         OOTRACEINFO3("H.225 Release Complete message received (%s, %s)\n",
+                      call->callType, call->callToken);
+
+         ooOnReceivedReleaseComplete(call, q931Msg);
+         
+         ooFreeQ931Message(q931Msg);
+         break;
+      case Q931FacilityMsg: 
+         OOTRACEINFO3("H.225 Facility message Received (%s, %s)\n",
+                       call->callType, call->callToken);
+
+         ooOnReceivedFacility(call, q931Msg); 
+         ooFreeQ931Message(q931Msg);
+         break;
+      case Q931ProgressMsg:
+         OOTRACEINFO3("H.225 Progress message received (%s, %s)\n",
+                       call->callType, call->callToken);
+         ooFreeQ931Message(q931Msg);
+         break;
+      case Q931StatusMsg:
+         OOTRACEINFO3("H.225 Status message received (%s, %s)\n",
+                       call->callType, call->callToken);
+         ooFreeQ931Message(q931Msg);
+         break;
+      case Q931StatusEnquiryMsg:
+         OOTRACEINFO3("H.225 Status Inquiry message Received (%s, %s)\n",
+                       call->callType, call->callToken);
+         ooFreeQ931Message(q931Msg);
+         break;
+      case Q931SetupAckMsg:
+         OOTRACEINFO3("H.225 Setup Ack message received (%s, %s)\n",
+                       call->callType, call->callToken);
+         ooFreeQ931Message(q931Msg);
+         break;
+      case Q931NotifyMsg: 
+         OOTRACEINFO3("H.225 Notify message Received (%s, %s)\n",
+                       call->callType, call->callToken);
+         ooFreeQ931Message(q931Msg);
+         break;
+      default:
+         OOTRACEWARN3("Invalid H.225 message type received (%s, %s)\n",
+                      call->callType, call->callToken);
+         ooFreeQ931Message(q931Msg);
+   }
+   return ret;
+}
+
+int ooOnReceivedFacility(OOH323CallData *call, Q931Message * pQ931Msg)
+{
+   H225H323_UU_PDU * pH323UUPdu = NULL;
+   H225Facility_UUIE * facility = NULL;
+   int ret;
+   H225TransportAddress_ipAddress_ip *ip = NULL;
+   OOTRACEDBGC3("Received Facility Message.(%s, %s)\n", call->callType, 
+                                                        call->callToken);
+   /* Get Reference to H323_UU_PDU */
+   if(!pQ931Msg->userInfo)
+   {
+      OOTRACEERR3("Error: UserInfo not found in received H.225 Facility "
+                  "message (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   pH323UUPdu = &pQ931Msg->userInfo->h323_uu_pdu;
+   if(!pH323UUPdu)
+   {
+      OOTRACEERR1("ERROR: H225H323_UU_PDU absent in incoming facility "
+                  "message\n");
+      return OO_FAILED;
+   }
+   facility = pH323UUPdu->h323_message_body.u.facility;
+   if(facility)
+   {
+      /* Depending on the reason of facility message handle the message */
+      if(facility->reason.t == T_H225FacilityReason_transportedInformation)
+      {
+         if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+         {
+            OOTRACEDBGB3("Handling tunneled messages in Facility. (%s, %s)\n",
+               call->callType, call->callToken);
+            ooHandleTunneledH245Messages(call, pH323UUPdu);
+            OOTRACEDBGB3("Finished handling tunneled messages in Facility."
+                         "(%s, %s)\n",call->callType, call->callToken);
+         }
+         else
+         {
+            OOTRACEERR3("ERROR:Tunneled H.245 message received in facility. "
+                        "Tunneling is disabled at local for this call (%s, %s)\n",
+                        call->callType, call->callToken);
+            return OO_FAILED;
+         }
+      }
+      else if(facility->reason.t == T_H225FacilityReason_startH245)
+      {
+         OOTRACEINFO3("Remote wants to start a separate H.245 Channel "
+                      "(%s, %s)\n", call->callType, call->callToken);
+         /*start H.245 channel*/
+         ret = ooHandleStartH245FacilityMessage(call, facility);
+         if(ret != OO_OK)
+         {
+            OOTRACEERR3("ERROR: Handling startH245 facility message "
+                        "(%s, %s)\n", call->callType, call->callToken);
+            return ret;
+         }
+      }
+      else if(facility->reason.t == T_H225FacilityReason_callForwarded)
+      {
+         OOTRACEINFO3("Call Forward Facility message received. (%s, %s)\n",
+                      call->callType, call->callToken);
+         if(!facility->m.alternativeAddressPresent && 
+            !facility->m.alternativeAliasAddressPresent)
+         {
+            OOTRACEERR3("Error:No alternative address provided in call forward"
+                       "facility message.(%s, %s)\n", call->callType, 
+                        call->callToken);
+            if(call->callState < OO_CALL_CLEAR)
+            {
+               call->callState = OO_CALL_CLEAR;
+               call->callEndReason = OO_REASON_INVALIDMESSAGE;
+            }
+            return OO_OK;
+         }
+         call->pCallFwdData = (OOCallFwdData *) memAlloc(call->pctxt, 
+                                                        sizeof(OOCallFwdData));
+         if(!call->pCallFwdData)
+         {
+            OOTRACEERR3("Error:Memory - ooOnReceivedFacility - pCallFwdData "
+                        "(%s, %s)\n", call->callType, call->callToken);
+            return OO_FAILED;
+         }
+         call->pCallFwdData->fwdedByRemote = TRUE;
+         call->pCallFwdData->ip[0]='\0';
+         call->pCallFwdData->aliases = NULL;
+         if(facility->m.alternativeAddressPresent)
+         {
+            if(facility->alternativeAddress.t != 
+                                           T_H225TransportAddress_ipAddress)
+            {
+               OOTRACEERR3("ERROR: Source call signalling address type not ip "
+                           "(%s, %s)\n", call->callType, call->callToken);
+           
+               return OO_FAILED;
+            }
+
+            ip = &facility->alternativeAddress.u.ipAddress->ip;
+            sprintf(call->pCallFwdData->ip, "%d.%d.%d.%d", ip->data[0], 
+                                       ip->data[1], ip->data[2], ip->data[3]);
+            call->pCallFwdData->port =  
+                               facility->alternativeAddress.u.ipAddress->port;
+         }
+
+         if(facility->m.alternativeAliasAddressPresent)
+         {
+            ooH323RetrieveAliases(call, &facility->alternativeAliasAddress, 
+                                  &call->pCallFwdData->aliases);
+         }
+         /* Now we have to clear the current call and make a new call to
+            fwded location*/
+         if(call->callState < OO_CALL_CLEAR)
+         {
+            call->callState = OO_CALL_CLEAR;
+            call->callEndReason = OO_REASON_REMOTE_FWDED;
+         }
+         else{
+            OOTRACEERR3("Error:Can't forward call as it is being cleared."
+                        " (%s, %s)\n", call->callType, call->callToken);
+           return OO_OK;
+         }
+      }
+      else{
+         OOTRACEINFO3("Unhandled Facility reason type received (%s, %s)\n", 
+                       call->callType, call->callToken);
+      }
+   }
+   else{ /* Empty facility message Check for tunneling */
+      OOTRACEDBGB3("Handling tunneled messages in empty Facility message."
+                   " (%s, %s)\n", call->callType, call->callToken);
+      ooHandleTunneledH245Messages(call, pH323UUPdu);
+      OOTRACEDBGB3("Finished handling tunneled messages in empty Facility "
+                   "message. (%s, %s)\n", call->callType, call->callToken);
+   }
+   
+   return OO_OK;
+}
+
+int ooHandleStartH245FacilityMessage
+   (OOH323CallData *call, H225Facility_UUIE *facility)
+{
+   H225TransportAddress_ipAddress *ipAddress = NULL;
+   int ret;
+   
+   /* Extract H245 address */
+   if(!facility->m.h245AddressPresent)
+   {
+      OOTRACEERR3("ERROR: startH245 facility message received with no h245 "
+                  "address (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   if(facility->h245Address.t != T_H225TransportAddress_ipAddress)
+   {
+      OOTRACEERR3("ERROR:Unknown H245 address type in received startH245 "
+               "facility message (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ipAddress = facility->h245Address.u.ipAddress;
+   if(!ipAddress)
+   {
+      OOTRACEERR3("ERROR:Invalid startH245 facility message. No H245 ip "
+                  "address found. (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   
+   sprintf(call->remoteIP, "%d.%d.%d.%d", ipAddress->ip.data[0],
+                                          ipAddress->ip.data[1],
+                                          ipAddress->ip.data[2],
+                                          ipAddress->ip.data[3]);
+   call->remoteH245Port = ipAddress->port;
+
+   /* disable tunneling for this call */
+   OO_CLRFLAG (call->flags, OO_M_TUNNELING);
+
+   /*Establish an H.245 connection */
+   ret = ooCreateH245Connection(call);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR: Failed to establish an H.245 connection with remote"
+                  " endpoint (%s, %s)\n", call->callType, call->callToken);
+      return ret;
+   }
+   return OO_OK;
+}
+
+int ooHandleTunneledH245Messages
+   (OOH323CallData *call, H225H323_UU_PDU * pH323UUPdu)
+{
+   H245Message *pmsg;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   int ret=0,i=0;
+   
+   OOTRACEDBGC3("Checking for tunneled H.245 messages (%s, %s)\n", 
+                 call->callType, call->callToken);
+
+   /* Check whether there are tunneled messages */  
+   if(pH323UUPdu->m.h245TunnelingPresent)
+   {
+      if(pH323UUPdu->h245Tunneling)
+      {
+         OOTRACEDBGB4("Total number of tunneled H245 messages are %d.(%s, %s)"
+                      "\n", (int)pH323UUPdu->h245Control.n, call->callType, 
+                      call->callToken);
+         for(i=0; i< (int)pH323UUPdu->h245Control.n; i++)
+         {
+            OOTRACEDBGC5("Retrieving %d of %d tunneled H.245 messages."
+                         "(%s, %s)\n",i+1, pH323UUPdu->h245Control.n,
+                         call->callType, call->callToken);
+            pmsg = (H245Message*)memAlloc(pctxt, sizeof(H245Message));
+            if(!pmsg)
+            {
+               OOTRACEERR3("Error:Memory - ooHandleH245TunneledMessages - pmsg"
+                          "(%s, %s)\n", call->callType, call->callToken);
+               return OO_FAILED;
+            }
+
+            setPERBuffer(pctxt, 
+                         (ASN1OCTET*)pH323UUPdu->h245Control.elem[i].data,
+                         pH323UUPdu->h245Control.elem[i].numocts, 1);  
+
+            initializePrintHandler(&printHandler, "Tunneled H.245 Message");
+            memset(pmsg, 0, sizeof(H245Message));
+            /* Set event handler */
+            setEventHandler (pctxt, &printHandler);
+            OOTRACEDBGC4("Decoding %d tunneled H245 message. (%s, %s)\n", 
+                          i+1, call->callType, call->callToken);
+            ret = asn1PD_H245MultimediaSystemControlMessage(pctxt, 
+                                                            &(pmsg->h245Msg));
+            if(ret != ASN_OK)
+            {
+               OOTRACEERR3("Error decoding H245 message (%s, %s)\n", 
+                            call->callType, call->callToken);
+               ooFreeH245Message(call,pmsg);
+               return OO_FAILED;
+            }
+            finishPrint();
+            removeEventHandler (pctxt);
+            ooHandleH245Message(call, pmsg);
+            memFreePtr(pctxt, pmsg);
+            pmsg = NULL;
+         }/* End of For loop */
+      }/* End of if(h245Tunneling) */
+   }
+   return OO_OK;
+}
+
+int ooH323RetrieveAliases
+   (OOH323CallData *call, H225_SeqOfH225AliasAddress *pAddresses, 
+    OOAliases **aliasList)
+{
+   int i=0,j=0,k=0;
+   DListNode* pNode=NULL;
+   H225AliasAddress *pAliasAddress=NULL;
+   OOAliases *newAlias=NULL;
+   H225TransportAddress *pTransportAddrss=NULL;
+
+   if(!pAddresses)
+   {
+      OOTRACEWARN3("Warn:No Aliases present (%s, %s)\n", call->callType, 
+                    call->callToken);
+      return OO_OK;
+   }
+   /* check for aliases */
+   if(pAddresses->count<=0)
+      return OO_OK;
+   
+   for(i=0; i<(int)pAddresses->count; i++)
+   {
+      pNode = dListFindByIndex (pAddresses, i);
+
+      if(!pNode)
+         continue;
+
+      pAliasAddress = (H225AliasAddress*)pNode->data;
+
+      if(!pAliasAddress)
+         continue;
+
+      newAlias = (OOAliases*)memAlloc(call->pctxt, sizeof(OOAliases));
+      if(!newAlias)
+      {
+         OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - newAlias "
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      memset(newAlias, 0, sizeof(OOAliases));
+      switch(pAliasAddress->t)
+      {
+      case T_H225AliasAddress_dialedDigits:
+         newAlias->type = T_H225AliasAddress_dialedDigits;
+         newAlias->value = (char*) memAlloc(call->pctxt, 
+                         strlen(pAliasAddress->u.dialedDigits)*sizeof(char)+1);
+         if(!newAlias->value)
+         {
+            OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - "
+                        "newAlias->value(dialedDigits) (%s, %s)\n", 
+                         call->callType, call->callToken);
+            memFreePtr(call->pctxt, newAlias);  
+            return OO_FAILED;
+         }
+
+         memcpy(newAlias->value, pAliasAddress->u.dialedDigits,
+                           strlen(pAliasAddress->u.dialedDigits)*sizeof(char));
+         newAlias->value[strlen(pAliasAddress->u.dialedDigits)*sizeof(char)]='\0';
+         break;
+      case T_H225AliasAddress_h323_ID:
+         newAlias->type = T_H225AliasAddress_h323_ID;
+         newAlias->value = (char*)memAlloc(call->pctxt, 
+                         (pAliasAddress->u.h323_ID.nchars+1)*sizeof(char)+1);
+         if(!newAlias->value)
+         {
+            OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - "
+                        "newAlias->value(h323id) (%s, %s)\n", call->callType, 
+                         call->callToken);
+            memFreePtr(call->pctxt, newAlias);  
+            return OO_FAILED;
+         }
+
+         for(j=0, k=0; j<(int)pAliasAddress->u.h323_ID.nchars; j++)
+         {
+            if(pAliasAddress->u.h323_ID.data[j] < 256)
+            {
+               newAlias->value[k++] = (char) pAliasAddress->u.h323_ID.data[j];
+            }
+         }
+         newAlias->value[k] = '\0';
+         break;   
+      case T_H225AliasAddress_url_ID:
+         newAlias->type = T_H225AliasAddress_url_ID;
+         newAlias->value = (char*)memAlloc(call->pctxt,
+                              strlen(pAliasAddress->u.url_ID)*sizeof(char)+1);
+         if(!newAlias->value)
+         {
+            OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - "
+                        "newAlias->value(urlid) (%s, %s)\n", call->callType, 
+                         call->callToken);
+            memFreePtr(call->pctxt, newAlias);  
+            return OO_FAILED;
+         }
+
+         memcpy(newAlias->value, pAliasAddress->u.url_ID,
+                               strlen(pAliasAddress->u.url_ID)*sizeof(char));
+         newAlias->value[strlen(pAliasAddress->u.url_ID)*sizeof(char)]='\0';
+         break;
+      case T_H225AliasAddress_transportID:
+         newAlias->type = T_H225AliasAddress_transportID;
+         pTransportAddrss = pAliasAddress->u.transportID;
+         if(pTransportAddrss->t != T_H225TransportAddress_ipAddress)
+         {
+            OOTRACEERR3("Error:Alias transportID not an IP address"
+                        "(%s, %s)\n", call->callType, call->callToken);
+            memFreePtr(call->pctxt, newAlias);
+            break;
+         }
+         /* hopefully ip:port value can't exceed more than 30 
+            characters */
+         newAlias->value = (char*)memAlloc(call->pctxt, 
+                                                      30*sizeof(char));
+         sprintf(newAlias->value, "%d.%d.%d.%d:%d", 
+                                  pTransportAddrss->u.ipAddress->ip.data[0],
+                                  pTransportAddrss->u.ipAddress->ip.data[1],
+                                  pTransportAddrss->u.ipAddress->ip.data[2],
+                                  pTransportAddrss->u.ipAddress->ip.data[3],
+                                  pTransportAddrss->u.ipAddress->port);
+         break;
+      case T_H225AliasAddress_email_ID:
+         newAlias->type = T_H225AliasAddress_email_ID;
+         newAlias->value = (char*)memAlloc(call->pctxt, 
+                             strlen(pAliasAddress->u.email_ID)*sizeof(char)+1);
+         if(!newAlias->value)
+         {
+            OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - "
+                        "newAlias->value(emailid) (%s, %s)\n", call->callType, 
+                         call->callToken);
+            memFreePtr(call->pctxt, newAlias);  
+            return OO_FAILED;
+         }
+
+         memcpy(newAlias->value, pAliasAddress->u.email_ID,
+                              strlen(pAliasAddress->u.email_ID)*sizeof(char));
+         newAlias->value[strlen(pAliasAddress->u.email_ID)*sizeof(char)]='\0';
+         break;
+      default:
+         OOTRACEERR3("Error:Unhandled Alias type (%s, %s)\n", 
+                       call->callType, call->callToken);
+         memFreePtr(call->pctxt, newAlias);
+         continue;
+      }
+
+      newAlias->next = *aliasList;
+      *aliasList = newAlias;
+
+      newAlias = NULL;
+     
+     pAliasAddress = NULL;
+     pNode = NULL;
+   }/* endof: for */
+   return OO_OK;
+}
+
+
+int ooPopulateAliasList(OOCTXT *pctxt, OOAliases *pAliases,
+                           H225_SeqOfH225AliasAddress *pAliasList )
+{
+   H225AliasAddress *pAliasEntry=NULL;
+   OOAliases * pAlias=NULL;
+   ASN1BOOL bValid=FALSE;
+   int i = 0;
+
+   dListInit(pAliasList);
+   if(pAliases)
+   {
+      pAlias = pAliases;
+      while(pAlias)
+      {
+         pAliasEntry = (H225AliasAddress*)memAlloc(pctxt, 
+                                                     sizeof(H225AliasAddress));
+         if(!pAliasEntry)
+         {
+            OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - pAliasEntry\n");
+            return OO_FAILED;
+         }
+         switch(pAlias->type)
+         {
+         case T_H225AliasAddress_dialedDigits:
+            pAliasEntry->t = T_H225AliasAddress_dialedDigits;
+            pAliasEntry->u.dialedDigits = (ASN1IA5String)memAlloc(pctxt,
+                                                     strlen(pAlias->value)+1);
+            if(!pAliasEntry->u.dialedDigits)
+            {
+               OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - "
+                           "dialedDigits\n");
+               memFreePtr(pctxt, pAliasEntry);
+               return OO_FAILED;
+            }
+            strcpy((char*)pAliasEntry->u.dialedDigits, pAlias->value);
+            bValid = TRUE;
+            break;
+         case T_H225AliasAddress_h323_ID:
+            pAliasEntry->t = T_H225AliasAddress_h323_ID;
+            pAliasEntry->u.h323_ID.nchars = strlen(pAlias->value);
+            pAliasEntry->u.h323_ID.data = (ASN116BITCHAR*)memAllocZ
+                     (pctxt, strlen(pAlias->value)*sizeof(ASN116BITCHAR));
+            
+            if(!pAliasEntry->u.h323_ID.data)
+            {
+               OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - h323_id\n");
+               memFreePtr(pctxt, pAliasEntry);
+               return OO_FAILED;
+            }
+            for(i=0; *(pAlias->value+i) != '\0'; i++)
+               pAliasEntry->u.h323_ID.data[i] =(ASN116BITCHAR)pAlias->value[i];
+            bValid = TRUE;
+            break;
+         case T_H225AliasAddress_url_ID:
+            pAliasEntry->t = T_H225AliasAddress_url_ID;
+            pAliasEntry->u.url_ID = (ASN1IA5String)memAlloc(pctxt, 
+                                                     strlen(pAlias->value)+1);
+            if(!pAliasEntry->u.url_ID)
+            {
+               OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - url_id\n");
+               memFreePtr(pctxt, pAliasEntry);               
+               return OO_FAILED;
+            }
+            strcpy((char*)pAliasEntry->u.url_ID, pAlias->value);
+            bValid = TRUE;
+            break;
+         case T_H225AliasAddress_email_ID:
+            pAliasEntry->t = T_H225AliasAddress_email_ID;
+            pAliasEntry->u.email_ID = (ASN1IA5String)memAlloc(pctxt, 
+                                                     strlen(pAlias->value)+1);
+            if(!pAliasEntry->u.email_ID)
+            {
+               OOTRACEERR1("ERROR: Failed to allocate memory for EmailID "
+                           "alias entry \n");
+               return OO_FAILED;
+            }
+            strcpy((char*)pAliasEntry->u.email_ID, pAlias->value);
+            bValid = TRUE;
+            break;
+         default:
+            OOTRACEERR1("ERROR: Unhandled alias type\n");
+            bValid = FALSE;                  
+         }
+         
+         if(bValid)
+            dListAppend( pctxt, pAliasList, (void*)pAliasEntry );
+         else
+            memFreePtr(pctxt, pAliasEntry);
+         
+         pAlias = pAlias->next;
+      }
+   }
+   return OO_OK;
+}
+
+
+OOAliases* ooH323GetAliasFromList(OOAliases *aliasList, int type, char *value)
+{
+
+   OOAliases *pAlias = NULL;
+
+   if(!aliasList)
+   {
+      OOTRACEDBGC1("No alias List to search\n");
+      return NULL;
+   }
+
+   pAlias = aliasList;
+
+   while(pAlias)
+   {
+     if(type != 0 && value) { /* Search by type and value */
+         if(pAlias->type == type && !strcmp(pAlias->value, value))
+         {
+            return pAlias;
+         }
+      }
+      else if(type != 0 && !value) {/* search by type */
+         if(pAlias->type == type)
+            return pAlias;
+      }
+      else if(type == 0 && value) {/* search by value */
+         if(!strcmp(pAlias->value, value))
+            return pAlias;
+      }
+      else {
+         OOTRACEDBGC1("No criteria to search the alias list\n");
+         return NULL;
+      }
+      pAlias = pAlias->next;
+   }
+
+   return NULL;
+}
+
+OOAliases* ooH323AddAliasToList
+(OOAliases **pAliasList, OOCTXT *pctxt, H225AliasAddress *pAliasAddress)
+{
+   int j=0,k=0;
+   OOAliases *newAlias=NULL;
+   H225TransportAddress *pTransportAddrss=NULL;
+   
+   newAlias = (OOAliases*) memAlloc(pctxt, sizeof(OOAliases));
+   if(!newAlias)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for new alias to be added to the alias list\n");
+      return NULL;
+   }
+   memset(newAlias, 0, sizeof(OOAliases));
+
+   switch(pAliasAddress->t)
+   {
+   case T_H225AliasAddress_dialedDigits:
+      newAlias->type = T_H225AliasAddress_dialedDigits;
+      newAlias->value = (char*) memAlloc(pctxt, strlen(pAliasAddress->u.dialedDigits)*sizeof(char)+1);
+      strcpy(newAlias->value, pAliasAddress->u.dialedDigits);
+      break;
+   case T_H225AliasAddress_h323_ID:
+      newAlias->type = T_H225AliasAddress_h323_ID;
+      newAlias->value = (char*)memAlloc(pctxt, 
+                           (pAliasAddress->u.h323_ID.nchars+1)*sizeof(char)+1);
+
+      for(j=0, k=0; j<(int)pAliasAddress->u.h323_ID.nchars; j++)
+      {
+         if(pAliasAddress->u.h323_ID.data[j] < 256)
+         {
+            newAlias->value[k++] = (char) pAliasAddress->u.h323_ID.data[j];
+         }
+      }
+      newAlias->value[k] = '\0';
+      break;   
+   case T_H225AliasAddress_url_ID:
+      newAlias->type = T_H225AliasAddress_url_ID;
+      newAlias->value = (char*)memAlloc(pctxt,
+                            strlen(pAliasAddress->u.url_ID)*sizeof(char)+1);
+
+      strcpy(newAlias->value, pAliasAddress->u.url_ID);
+      break;
+   case T_H225AliasAddress_transportID:
+      newAlias->type = T_H225AliasAddress_transportID;
+      pTransportAddrss = pAliasAddress->u.transportID;
+      if(pTransportAddrss->t != T_H225TransportAddress_ipAddress)
+      {
+         OOTRACEERR1("Error:Alias transportID not an IP address\n");
+         memFreePtr(pctxt, newAlias);
+         return NULL;
+      }
+      /* hopefully ip:port value can't exceed more than 30 
+         characters */
+      newAlias->value = (char*)memAlloc(pctxt, 
+                                              30*sizeof(char));
+      sprintf(newAlias->value, "%d.%d.%d.%d:%d", 
+                               pTransportAddrss->u.ipAddress->ip.data[0],
+                               pTransportAddrss->u.ipAddress->ip.data[1],
+                               pTransportAddrss->u.ipAddress->ip.data[2],
+                               pTransportAddrss->u.ipAddress->ip.data[3],
+                               pTransportAddrss->u.ipAddress->port);
+      break;
+   case T_H225AliasAddress_email_ID:
+      newAlias->type = T_H225AliasAddress_email_ID;
+      newAlias->value = (char*)memAlloc(pctxt, 
+                 strlen(pAliasAddress->u.email_ID)*sizeof(char)+1);
+
+      strcpy(newAlias->value, pAliasAddress->u.email_ID);
+      break;
+   default:
+      OOTRACEERR1("Error:Unhandled Alias type \n");
+      memFreePtr(pctxt, newAlias);
+      return NULL;
+
+   }
+   newAlias->next = *pAliasList;
+   *pAliasList= newAlias;
+   return newAlias;
+}
+
+int ooH323GetIpPortFromH225TransportAddress(struct OOH323CallData *call, 
+   H225TransportAddress *h225Address, char *ip, int *port)
+{
+   if(h225Address->t != T_H225TransportAddress_ipAddress)
+   {
+      OOTRACEERR3("Error: Unknown H225 address type. (%s, %s)", call->callType,
+                   call->callToken);
+      return OO_FAILED;
+   }
+   sprintf(ip, "%d.%d.%d.%d", 
+              h225Address->u.ipAddress->ip.data[0], 
+              h225Address->u.ipAddress->ip.data[1],
+              h225Address->u.ipAddress->ip.data[2],
+              h225Address->u.ipAddress->ip.data[3]);
+   *port = h225Address->u.ipAddress->port;
+   return OO_OK;
+}
diff --git a/addons/ooh323c/src/ooh323.h b/addons/ooh323c/src/ooh323.h
new file mode 100644
index 000000000..8c5a99434
--- /dev/null
+++ b/addons/ooh323c/src/ooh323.h
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/**
+ * @file ooh323.h 
+ * This file contains functions to support H.225 messages. 
+ */
+#ifndef _OOH323HDR_H_
+#define _OOH323HDR_H_
+
+#include "ooasn1.h"
+#include "ootypes.h"
+#include "ootrace.h"
+#include "ooq931.h"
+#include "MULTIMEDIA-SYSTEM-CONTROL.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+struct OOH323CallData;
+
+/**
+ * @addtogroup q931
+ * @{
+ */
+/**
+ * This function is used to process a received SETUP message.
+ * @param call     Pointer to call for which SETUP message is received.
+ * @param q931Msg  Pointer to the received SETUP message.
+ *
+ * @return         OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedSetup
+(struct OOH323CallData *call, Q931Message *q931Msg);
+
+/**
+ * This function is used to process a received CONNECT message.
+ * It creates H.245 negotiation channel, and starts TCS and MSD
+ * procedures.
+ * @param call      Pointer to call for which CONNECT message is received.
+ * @param q931Msg   Pointer to the received q931Msg
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedSignalConnect
+(struct OOH323CallData* call, Q931Message *q931Msg);
+
+/**
+ * This function is used to handle received H.2250 messages. It
+ * calls helper functions based on the type of message received.
+ * @param call       Pointer to the call for which a H.2250 message is received
+ * @param q931Msg    Pointer to the received q931Msg
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooHandleH2250Message
+(struct OOH323CallData *call, Q931Message *q931Msg);
+
+/**
+ * This function is used to process a received Facility message.
+ * @param call       Handle to the call for which message has been received.
+ * @param pQ931Msg   Pointer the the received Facility message.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooOnReceivedFacility
+(struct OOH323CallData *call, Q931Message * pQ931Msg);
+
+/**
+ * This function is used to process tunneled H245 messages
+ * @param call       Handle to the call
+ * @param pH323UUPdu Pointer to the pdu containing tunneled messages.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooHandleTunneledH245Messages(struct OOH323CallData *call, 
+                                        H225H323_UU_PDU * pH323UUPdu);
+
+/**
+ * This is a helper function used to handle an startH245 Facility message.
+ * @param call       Handle to the call
+ * @param facility   Pointer to the facility message.
+ */
+EXTERN int ooHandleStartH245FacilityMessage(struct OOH323CallData *call, 
+                                            H225Facility_UUIE *facility);
+
+/**
+ * This function is used to retrieve the aliases from Sequence of alias
+ * addresses.
+ * @param call       Handle to the call.Null when retrieving registered
+ *                   aliases.
+ * @param pAddresses Pointer to the sequence of alias addresses.
+ * @param aliasList  Handle to alias list to be populated with retrieved 
+ *                   aliases.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323RetrieveAliases
+   (struct OOH323CallData *call, H225_SeqOfH225AliasAddress *pAddresses, 
+    OOAliases **aliasList);
+
+/**
+ * This is a helper function used to populate alias list using aliases.
+ * @param pctxt      Pointer to OOCTXT structure which will be used for memory
+ *                   allocations.
+ * @param pAliases   Pointer to aliases to be used for populating list.
+ * @param pAliasList Pointer to alias list to be populated.
+ *
+ * @return           OO_OK, on success. OO_FAILED, otherwise. 
+ */
+EXTERN int ooPopulateAliasList(OOCTXT *pctxt, OOAliases *pAliases,
+                               H225_SeqOfH225AliasAddress *pAliasList); 
+
+/**
+ * This function is used to search a particular alias in the alias list. The
+ * search can be on the basis of alias type or value or both.
+ * @param aliasList Handle to the alias list to be searched.
+ * @param type      Type of the alias, if search has to consider type as 
+ *                  criterion, otherwise 0.
+ * @param value     Value of the alias, if the search has to consider value as
+ *                  criterion, NULL otherwise.
+ */
+EXTERN OOAliases* ooH323GetAliasFromList
+                               (OOAliases *aliasList, int type, char *value);
+
+/**
+ * This function is used to add a new alias to alias list.
+ * @param pAliasList    Pointer to Alias list.
+ * @param pctxt         Pointer to OOCTXT structure to be used for memory 
+ *                      allocation.
+ * @param pAliasAddress New alias address to be added.
+ *
+ * @return              Handle to newly added alias or NULL in case of failure.
+ */
+EXTERN OOAliases* ooH323AddAliasToList
+(OOAliases **pAliasList, OOCTXT *pctxt, H225AliasAddress *pAliasAddress);
+
+/**
+ * This function is used to retrieve ip address and port number from an
+ * H225TransportAddress structure.
+ * @param call          Handle to the associated call.
+ * @param h225Address   Pointer to H225TransportAddress structure
+ * @param ip            Pointer to the buffer in which dotted ip address will
+ *                      be returned.
+ * @param port          Pointer to the integer in which port value will be 
+ *                      returned.
+ *
+ * @return              OO_OK, on success; OO_FAILED, on failure.
+ */
+int ooH323GetIpPortFromH225TransportAddress(struct OOH323CallData *call, 
+   H225TransportAddress *h225Address, char *ip, int *port);
+/**
+ * @}
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/addons/ooh323c/src/ooh323ep.c b/addons/ooh323c/src/ooh323ep.c
new file mode 100644
index 000000000..93e2ec3a3
--- /dev/null
+++ b/addons/ooh323c/src/ooh323ep.c
@@ -0,0 +1,789 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+#include "ooh323ep.h"
+#include "ootrace.h"
+#include "ooCalls.h"
+#include "ooCapability.h"
+#include "ooGkClient.h"
+#include "ooStackCmds.h"
+#include "ooCmdChannel.h"
+/** Global endpoint structure */
+ooEndPoint gH323ep;
+
+
+extern DList g_TimerList;
+
+int ooH323EpInitialize
+   (enum OOCallMode callMode, const char* tracefile)
+{
+   
+   memset(&gH323ep, 0, sizeof(ooEndPoint));
+
+   initContext(&(gH323ep.ctxt));
+   initContext(&(gH323ep.msgctxt));
+
+   if(tracefile)
+   {
+      if(strlen(tracefile)>= MAXFILENAME)
+      {
+         printf("Error:File name longer than allowed maximum %d\n", 
+                 MAXFILENAME-1);
+         return OO_FAILED;
+      }
+      strcpy(gH323ep.traceFile, tracefile);
+   }
+   else{
+      strcpy(gH323ep.traceFile, DEFAULT_TRACEFILE);      
+   }
+
+   gH323ep.fptraceFile = fopen(gH323ep.traceFile, "w");
+   if(gH323ep.fptraceFile == NULL)
+   {
+      printf("Error:Failed to open trace file %s for write.\n", 
+                  gH323ep.traceFile);
+      return OO_FAILED;
+   }
+
+   /* Initialize default port ranges that will be used by stack. 
+      Apps can override these by explicitely setting port ranges
+   */
+
+   gH323ep.tcpPorts.start = TCPPORTSSTART;
+   gH323ep.tcpPorts.max = TCPPORTSEND;
+   gH323ep.tcpPorts.current=TCPPORTSSTART;
+
+   gH323ep.udpPorts.start = UDPPORTSSTART;
+   gH323ep.udpPorts.max = UDPPORTSEND;
+   gH323ep.udpPorts.current = UDPPORTSSTART;
+
+   gH323ep.rtpPorts.start = RTPPORTSSTART;
+   gH323ep.rtpPorts.max = RTPPORTSEND;
+   gH323ep.rtpPorts.current = RTPPORTSSTART;
+   
+   OO_SETFLAG(gH323ep.flags, OO_M_FASTSTART);
+   OO_SETFLAG(gH323ep.flags, OO_M_TUNNELING);
+   OO_SETFLAG(gH323ep.flags, OO_M_AUTOANSWER);
+   OO_CLRFLAG(gH323ep.flags, OO_M_GKROUTED);
+   
+   gH323ep.aliases = NULL;
+
+   gH323ep.termType = DEFAULT_TERMTYPE;
+
+   gH323ep.t35CountryCode = DEFAULT_T35COUNTRYCODE;
+
+   gH323ep.t35Extension = DEFAULT_T35EXTENSION;
+
+   gH323ep.manufacturerCode = DEFAULT_MANUFACTURERCODE;
+
+   gH323ep.productID = DEFAULT_PRODUCTID;
+
+   gH323ep.versionID = OOH323C_VERSION;
+
+   gH323ep.callType = T_H225CallType_pointToPoint;
+   ooGetLocalIPAddress(gH323ep.signallingIP);
+   gH323ep.listenPort = DEFAULT_H323PORT;
+
+   gH323ep.listener = NULL;
+
+   ooH323EpSetCallerID(DEFAULT_CALLERID);
+
+   
+   gH323ep.myCaps = NULL;
+   gH323ep.noOfCaps = 0;
+   gH323ep.callList = NULL;
+   gH323ep.dtmfmode = 0;
+   gH323ep.callingPartyNumber[0]='\0';     
+   gH323ep.callMode = callMode;
+   gH323ep.isGateway = FALSE;
+
+   dListInit(&g_TimerList);/* This is for test application chansetup only*/
+
+   gH323ep.callEstablishmentTimeout = DEFAULT_CALLESTB_TIMEOUT;
+
+   gH323ep.msdTimeout = DEFAULT_MSD_TIMEOUT;
+
+   gH323ep.tcsTimeout = DEFAULT_TCS_TIMEOUT;
+
+   gH323ep.logicalChannelTimeout = DEFAULT_LOGICALCHAN_TIMEOUT;
+
+   gH323ep.sessionTimeout = DEFAULT_ENDSESSION_TIMEOUT;
+   gH323ep.ifList = NULL;
+
+   ooSetTraceThreshold(OOTRCLVLINFO);
+   OO_SETFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED);
+
+   gH323ep.cmdSock = 0;
+   return OO_OK;
+}
+
+EXTERN int ooH323EpSetAsGateway()
+{
+   gH323ep.isGateway = TRUE;
+   return OO_OK;
+}
+
+
+int ooH323EpSetLocalAddress(const char* localip, int listenport)
+{
+   if(localip)
+   {
+      strcpy(gH323ep.signallingIP, localip);
+      OOTRACEINFO2("Signalling IP address is set to %s\n", localip);
+   }
+   
+   if(listenport)
+   {
+      gH323ep.listenPort = listenport;
+      OOTRACEINFO2("Listen port number is set to %d\n", listenport);
+   }
+   return OO_OK;
+}
+
+int ooH323EpAddAliasH323ID(const char *h323id)
+{
+   ooAliases * psNewAlias=NULL;
+   psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases));
+   if(!psNewAlias)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for new H323-ID alias\n");
+      return OO_FAILED;
+   }
+   psNewAlias->type = T_H225AliasAddress_h323_ID;
+   psNewAlias->registered = FALSE;
+   psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(h323id)+1);
+   if(!psNewAlias->value)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for the new H323-ID alias "
+                  "value\n");
+      memFreePtr(&gH323ep.ctxt, psNewAlias);
+      return OO_FAILED;
+   }
+   strcpy(psNewAlias->value, h323id);
+   psNewAlias->next = gH323ep.aliases;
+   gH323ep.aliases = psNewAlias;
+   OOTRACEDBGA2("Added alias: H323ID - %s\n", h323id);
+   return OO_OK;
+}
+
+int ooH323EpAddAliasDialedDigits(const char* dialedDigits)
+{
+   ooAliases * psNewAlias=NULL;
+   psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases));
+   if(!psNewAlias)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for new DialedDigits "
+                  "alias\n");
+      return OO_FAILED;
+   }
+   psNewAlias->type = T_H225AliasAddress_dialedDigits;
+   psNewAlias->registered = FALSE;
+   psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(dialedDigits)+1);
+   if(!psNewAlias->value)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for the new DialedDigits"
+                  " alias value\n");
+      memFreePtr(&gH323ep.ctxt, psNewAlias);
+      return OO_FAILED;
+   }
+   strcpy(psNewAlias->value, dialedDigits);
+   psNewAlias->next = gH323ep.aliases;
+   gH323ep.aliases = psNewAlias;
+   OOTRACEDBGA2("Added alias: DialedDigits - %s\n", dialedDigits);
+   return OO_OK;
+}
+
+int ooH323EpAddAliasURLID(const char * url)
+{
+   ooAliases * psNewAlias=NULL;
+   psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases));
+   if(!psNewAlias)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for new URL-ID alias\n");
+      return OO_FAILED;
+   }
+   psNewAlias->type = T_H225AliasAddress_url_ID;
+   psNewAlias->registered = FALSE;
+   psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(url)+1);
+   if(!psNewAlias->value)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for the new URL-ID alias"
+                  " value\n");
+      memFreePtr(&gH323ep.ctxt, psNewAlias);
+      return OO_FAILED;
+   }
+   strcpy(psNewAlias->value, url);
+   psNewAlias->next = gH323ep.aliases;
+   gH323ep.aliases = psNewAlias;
+   OOTRACEDBGA2("Added alias: URL-ID - %s\n", url);
+   return OO_OK;
+}
+
+int ooH323EpAddAliasEmailID(const char * email)
+{
+   ooAliases * psNewAlias=NULL;
+   psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases));
+   if(!psNewAlias)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for new Email-ID alias\n");
+      return OO_FAILED;
+   }
+   psNewAlias->type = T_H225AliasAddress_email_ID;
+   psNewAlias->registered = FALSE;
+   psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(email)+1);
+   if(!psNewAlias->value)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for the new Email-ID alias"
+                  " value\n");
+      memFreePtr(&gH323ep.ctxt, psNewAlias);
+      return OO_FAILED;
+   }
+   strcpy(psNewAlias->value, email);
+   psNewAlias->next = gH323ep.aliases;
+   gH323ep.aliases = psNewAlias;
+   OOTRACEDBGA2("Added alias: Email-ID - %s\n", email);
+   return OO_OK;
+}
+
+int ooH323EpAddAliasTransportID(const char * ipaddress)
+{
+   ooAliases * psNewAlias=NULL;
+   psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases));
+   if(!psNewAlias)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for new Transport-ID "
+                  "alias\n");
+      return OO_FAILED;
+   }
+   psNewAlias->type = T_H225AliasAddress_transportID;
+   psNewAlias->registered = FALSE;
+   psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(ipaddress)+1);
+   if(!psNewAlias->value)
+   {
+      OOTRACEERR1("Error: Failed to allocate memory for the new Transport-ID "
+                  "alias value\n");
+      memFreePtr(&gH323ep.ctxt, psNewAlias);
+      return OO_FAILED;
+   }
+   strcpy(psNewAlias->value, ipaddress);
+   psNewAlias->next = gH323ep.aliases;
+   gH323ep.aliases = psNewAlias;
+   OOTRACEDBGA2("Added alias: Transport-ID - %s\n", ipaddress);
+   return OO_OK;
+}
+
+int ooH323EpClearAllAliases(void)
+{
+   ooAliases *pAlias = NULL, *pTemp;
+   if(gH323ep.aliases)
+   {
+      pAlias = gH323ep.aliases;
+      while(pAlias)
+      {
+         pTemp = pAlias;
+         pAlias = pAlias->next;
+         memFreePtr(&gH323ep.ctxt, pTemp);
+      }
+      gH323ep.aliases = NULL;
+   }
+   return OO_OK;
+}
+
+
+int ooH323EpSetH225MsgCallbacks(OOH225MsgCallbacks h225Callbacks)
+{
+   gH323ep.h225Callbacks.onReceivedSetup = h225Callbacks.onReceivedSetup;
+   gH323ep.h225Callbacks.onReceivedConnect = h225Callbacks.onReceivedConnect;
+   gH323ep.h225Callbacks.onBuiltSetup = h225Callbacks.onBuiltSetup;
+   gH323ep.h225Callbacks.onBuiltConnect = h225Callbacks.onBuiltConnect;
+
+   return OO_OK;
+}
+    
+int ooH323EpSetH323Callbacks(OOH323CALLBACKS h323Callbacks)
+{
+   gH323ep.h323Callbacks.onNewCallCreated = h323Callbacks.onNewCallCreated;
+   gH323ep.h323Callbacks.onAlerting = h323Callbacks.onAlerting;
+   gH323ep.h323Callbacks.onIncomingCall = h323Callbacks.onIncomingCall;
+   gH323ep.h323Callbacks.onOutgoingCall = h323Callbacks.onOutgoingCall;
+   gH323ep.h323Callbacks.onCallEstablished = h323Callbacks.onCallEstablished;
+   gH323ep.h323Callbacks.onCallForwarded = h323Callbacks.onCallForwarded;
+   gH323ep.h323Callbacks.onCallCleared = h323Callbacks.onCallCleared;
+   gH323ep.h323Callbacks.openLogicalChannels = h323Callbacks.openLogicalChannels;
+   gH323ep.h323Callbacks.onReceivedDTMF = h323Callbacks.onReceivedDTMF;
+   return OO_OK;
+}
+
+int ooH323EpDestroy(void)
+{
+   /* free any internal memory allocated
+      close trace file free context structure
+   */
+   OOH323CallData * cur, *temp;
+   if(OO_TESTFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED))
+   {
+      OOTRACEINFO1("Destroying H323 Endpoint\n");
+      if(gH323ep.callList)
+      {
+         cur = gH323ep.callList;
+         while(cur)
+         {
+            temp = cur;
+            cur = cur->next;
+            temp->callEndReason = OO_REASON_LOCAL_CLEARED;
+            ooCleanCall(temp);
+         }
+         gH323ep.callList = NULL;
+      }
+
+
+      if(gH323ep.listener)
+      {
+         ooSocketClose(*(gH323ep.listener));
+         gH323ep.listener = NULL;   
+      }
+
+	  ooGkClientDestroy();  
+
+      if(gH323ep.fptraceFile)
+      {
+         fclose(gH323ep.fptraceFile);
+         gH323ep.fptraceFile = NULL;
+      }
+
+      freeContext(&(gH323ep.ctxt));
+
+      OO_CLRFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED);
+   }
+   return OO_OK;
+}
+
+int ooH323EpEnableGkRouted(void)
+{
+   OO_SETFLAG(gH323ep.flags, OO_M_GKROUTED);
+   return OO_OK;
+}
+
+int ooH323EpDisableGkRouted(void)
+{
+   OO_CLRFLAG(gH323ep.flags, OO_M_GKROUTED);
+   return OO_OK;
+}
+
+int ooH323EpEnableAutoAnswer(void)
+{
+   OO_SETFLAG(gH323ep.flags, OO_M_AUTOANSWER);
+   return OO_OK;
+}
+
+int ooH323EpDisableAutoAnswer(void)
+{
+   OO_CLRFLAG(gH323ep.flags, OO_M_AUTOANSWER);
+   return OO_OK;
+}
+
+int ooH323EpEnableManualRingback(void)
+{
+   OO_SETFLAG(gH323ep.flags, OO_M_MANUALRINGBACK);
+   return OO_OK;
+}
+
+
+int ooH323EpDisableManualRingback(void)
+{
+   OO_CLRFLAG(gH323ep.flags, OO_M_MANUALRINGBACK);
+   return OO_OK;
+}
+
+int ooH323EpEnableMediaWaitForConnect(void)
+{
+   OO_SETFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN);
+   return OO_OK;
+}
+
+int ooH323EpDisableMediaWaitForConnect(void)
+{
+   OO_CLRFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN);
+   return OO_OK;
+}
+
+int ooH323EpEnableFastStart(void)
+{
+   OO_SETFLAG(gH323ep.flags, OO_M_FASTSTART);
+   return OO_OK;
+}
+
+int ooH323EpDisableFastStart(void)
+{
+   OO_CLRFLAG(gH323ep.flags, OO_M_FASTSTART);
+   return OO_OK;
+}
+
+int ooH323EpEnableH245Tunneling(void)
+{
+   OO_SETFLAG(gH323ep.flags, OO_M_TUNNELING);
+   return OO_OK;
+}
+ 
+int ooH323EpDisableH245Tunneling(void)
+{
+   OO_CLRFLAG(gH323ep.flags, OO_M_TUNNELING);
+   return OO_OK;
+}
+
+int ooH323EpSetTermType(int value)
+{
+   gH323ep.termType = value;
+   return OO_OK;
+}
+
+int ooH323EpSetProductID (const char* productID)
+{
+   if (0 != productID) {
+      char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(productID)+1);
+      strcpy (pstr, productID);
+      if(gH323ep.productID)
+         memFreePtr(&gH323ep.ctxt, gH323ep.productID);
+      gH323ep.productID = pstr;
+      return OO_OK;
+   }
+   else return OO_FAILED;
+}
+
+int ooH323EpSetVersionID (const char* versionID)
+{
+   if (0 != versionID) {
+      char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(versionID)+1);
+      strcpy (pstr, versionID);
+      if(gH323ep.versionID)
+         memFreePtr(&gH323ep.ctxt, gH323ep.versionID);
+      gH323ep.versionID = pstr;
+      return OO_OK;
+   }
+   else return OO_FAILED;
+}
+
+int ooH323EpSetCallerID (const char* callerID)
+{
+   if (0 != callerID) {
+      char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(callerID)+1);
+      strcpy (pstr, callerID);
+      if(gH323ep.callerid)
+         memFreePtr(&gH323ep.ctxt, gH323ep.callerid);
+      gH323ep.callerid = pstr;
+      return OO_OK;
+   }
+   else return OO_FAILED;
+}
+
+int ooH323EpSetCallingPartyNumber(const char* number)
+{
+   int ret=OO_OK;
+   if(number)
+   {
+      strncpy(gH323ep.callingPartyNumber, number, 
+                                        sizeof(gH323ep.callingPartyNumber)-1);
+      ret = ooH323EpAddAliasDialedDigits((char*)number);
+      return ret;
+   }
+   else return OO_FAILED;
+}
+
+int ooH323EpSetTraceLevel(int traceLevel)
+{
+   ooSetTraceThreshold(traceLevel);
+   return OO_OK;
+}
+
+void ooH323EpPrintConfig(void)
+{
+   OOTRACEINFO1("H.323 Endpoint Configuration is as follows:\n");
+   
+   OOTRACEINFO2("\tTrace File: %s\n", gH323ep.traceFile);
+
+   if(!OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART))
+   {
+      OOTRACEINFO1("\tFastStart - disabled\n");
+   }
+   else{
+      OOTRACEINFO1("\tFastStart - enabled\n");
+   }
+
+   if(!OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING))
+   {
+      OOTRACEINFO1("\tH245 Tunneling - disabled\n");
+   }
+   else{
+      OOTRACEINFO1("\tH245 Tunneling - enabled\n");
+   }
+
+   if(!OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN))
+   {
+      OOTRACEINFO1("\tMediaWaitForConnect - disabled\n");
+   }
+   else{
+      OOTRACEINFO1("\tMediaWaitForConnect - enabled\n");
+   }
+
+   if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER))
+      OOTRACEINFO1("\tAutoAnswer - enabled\n");
+   else
+      OOTRACEINFO1("\tAutoAnswer - disabled\n");
+     
+   OOTRACEINFO2("\tTerminal Type - %d\n", gH323ep.termType);
+
+   OOTRACEINFO2("\tT35 CountryCode - %d\n", gH323ep.t35CountryCode);
+
+   OOTRACEINFO2("\tT35 Extension - %d\n", gH323ep.t35Extension);
+
+   OOTRACEINFO2("\tManufacturer Code - %d\n", gH323ep.manufacturerCode);
+
+   OOTRACEINFO2("\tProductID - %s\n", gH323ep.productID);
+   
+   OOTRACEINFO2("\tVersionID - %s\n", gH323ep.versionID);
+
+   OOTRACEINFO2("\tLocal signalling IP address - %s\n", gH323ep.signallingIP);
+
+   OOTRACEINFO2("\tH225 ListenPort - %d\n", gH323ep.listenPort);
+
+   OOTRACEINFO2("\tCallerID - %s\n", gH323ep.callerid);
+
+
+   OOTRACEINFO2("\tCall Establishment Timeout - %d seconds\n", 
+                                          gH323ep.callEstablishmentTimeout);   
+
+   OOTRACEINFO2("\tMasterSlaveDetermination Timeout - %d seconds\n",
+                   gH323ep.msdTimeout);
+
+   OOTRACEINFO2("\tTerminalCapabilityExchange Timeout - %d seconds\n",
+                   gH323ep.tcsTimeout);
+
+   OOTRACEINFO2("\tLogicalChannel  Timeout - %d seconds\n",
+                   gH323ep.logicalChannelTimeout);
+
+   OOTRACEINFO2("\tSession Timeout - %d seconds\n", gH323ep.sessionTimeout);
+
+   return;   
+}
+
+
+int ooH323EpAddG711Capability(int cap, int txframes, int rxframes, int dir,
+                              cb_StartReceiveChannel startReceiveChannel,
+                              cb_StartTransmitChannel startTransmitChannel,
+                              cb_StopReceiveChannel stopReceiveChannel,
+                              cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(NULL, cap, txframes, rxframes, FALSE,
+                            dir, startReceiveChannel, startTransmitChannel, 
+                            stopReceiveChannel, stopTransmitChannel, FALSE);
+}
+
+int ooH323EpAddG728Capability(int cap, int txframes, int rxframes, int dir,
+                              cb_StartReceiveChannel startReceiveChannel,
+                              cb_StartTransmitChannel startTransmitChannel,
+                              cb_StopReceiveChannel stopReceiveChannel,
+                              cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(NULL, cap, txframes, rxframes, FALSE,
+                               dir, startReceiveChannel, startTransmitChannel, 
+                               stopReceiveChannel, stopTransmitChannel, FALSE);
+}
+
+int ooH323EpAddG729Capability(int cap, int txframes, int rxframes, int dir,
+                              cb_StartReceiveChannel startReceiveChannel,
+                              cb_StartTransmitChannel startTransmitChannel,
+                              cb_StopReceiveChannel stopReceiveChannel,
+                              cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(NULL, cap, txframes, rxframes, FALSE,
+                               dir, startReceiveChannel, startTransmitChannel, 
+                               stopReceiveChannel, stopTransmitChannel, FALSE);
+}
+
+
+int ooH323EpAddG7231Capability(int cap, int txframes, int rxframes, 
+                              OOBOOL silenceSuppression, int dir,
+                              cb_StartReceiveChannel startReceiveChannel,
+                              cb_StartTransmitChannel startTransmitChannel,
+                              cb_StopReceiveChannel stopReceiveChannel,
+                              cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddSimpleCapability(NULL, cap, txframes, rxframes, 
+                             silenceSuppression, dir, startReceiveChannel, 
+                             startTransmitChannel, stopReceiveChannel, 
+                             stopTransmitChannel, FALSE);
+}
+
+int ooH323EpAddGSMCapability(int cap, ASN1USINT framesPerPkt, 
+                             OOBOOL comfortNoise, OOBOOL scrambled, int dir,
+                             cb_StartReceiveChannel startReceiveChannel,
+                             cb_StartTransmitChannel startTransmitChannel,
+                             cb_StopReceiveChannel stopReceiveChannel,
+                             cb_StopTransmitChannel stopTransmitChannel)
+{
+   return ooCapabilityAddGSMCapability(NULL, cap, framesPerPkt, comfortNoise, 
+                                     scrambled, dir, startReceiveChannel, 
+                                     startTransmitChannel, stopReceiveChannel,
+                                     stopTransmitChannel, FALSE);
+}
+
+
+int ooH323EpAddH263VideoCapability(int cap, unsigned sqcifMPI, 
+                                 unsigned qcifMPI, unsigned cifMPI, 
+                                 unsigned cif4MPI, unsigned cif16MPI, 
+                                 unsigned maxBitRate, int dir, 
+                                 cb_StartReceiveChannel startReceiveChannel,
+                                 cb_StartTransmitChannel startTransmitChannel,
+                                 cb_StopReceiveChannel stopReceiveChannel,
+                                 cb_StopTransmitChannel stopTransmitChannel)
+{
+
+   return ooCapabilityAddH263VideoCapability(NULL, sqcifMPI, qcifMPI, cifMPI, 
+                                     cif4MPI, cif16MPI, maxBitRate,dir,
+                                     startReceiveChannel, startTransmitChannel,
+                                     stopReceiveChannel, stopTransmitChannel, 
+                                     FALSE);
+
+}
+
+
+int ooH323EpEnableDTMFRFC2833(int dynamicRTPPayloadType)
+{
+   return ooCapabilityEnableDTMFRFC2833(NULL, dynamicRTPPayloadType);
+}
+
+int ooH323EpDisableDTMFRFC2833(void)
+{
+   return ooCapabilityDisableDTMFRFC2833(NULL);
+}
+
+int ooH323EpEnableDTMFH245Alphanumeric()
+{
+   return ooCapabilityEnableDTMFH245Alphanumeric(NULL);
+}
+
+int ooH323EpDisableDTMFH245Alphanumeric()
+{
+   return ooCapabilityDisableDTMFH245Alphanumeric(NULL);
+}
+
+int ooH323EpEnableDTMFH245Signal()
+{
+   return ooCapabilityEnableDTMFH245Signal(NULL);
+}
+
+int ooH323EpDisableDTMFH245Signal()
+{
+   return ooCapabilityDisableDTMFH245Signal(NULL);
+}
+
+int ooH323EpEnableDTMFQ931Keypad()
+{
+   return ooCapabilityEnableDTMFQ931Keypad(NULL);
+}
+
+int ooH323EpDisableDTMFQ931Keypad()
+{
+   return ooCapabilityDisableDTMFQ931Keypad(NULL);
+}
+
+int ooH323EpSetGkClientCallbacks(OOGKCLIENTCALLBACKS gkClientCallbacks)
+{
+
+   if(gH323ep.gkClient)
+   {
+      return ooGkClientSetCallbacks(gH323ep.gkClient, gkClientCallbacks);
+   }
+   else{
+      OOTRACEERR1("Error:Gk Client hasn't been initialized yet\n");
+      return OO_FAILED;
+   }
+
+}
+
+
+
+/* 0-1024 are reserved for well known services */
+int ooH323EpSetTCPPortRange(int base, int max)
+{
+   if(base <= 1024)
+      gH323ep.tcpPorts.start = 1025;
+   else
+      gH323ep.tcpPorts.start = base;
+   if(max > 65500)
+      gH323ep.tcpPorts.max = 65500;
+   else 
+      gH323ep.tcpPorts.max = max;
+
+   if(gH323ep.tcpPorts.max<gH323ep.tcpPorts.start)
+   {
+      OOTRACEERR1("Error: Failed to set tcp ports- "
+                  "Max port number less than Start port number\n");
+      return OO_FAILED;
+   }
+   gH323ep.tcpPorts.current = gH323ep.tcpPorts.start;
+        
+   OOTRACEINFO1("TCP port range initialize - successful\n");
+   return OO_OK;
+}
+
+int ooH323EpSetUDPPortRange(int base, int max)
+{
+   if(base <= 1024)
+      gH323ep.udpPorts.start = 1025;
+   else
+      gH323ep.udpPorts.start = base;
+   if(max > 65500)
+      gH323ep.udpPorts.max = 65500;
+   else 
+      gH323ep.udpPorts.max = max;
+        
+   if(gH323ep.udpPorts.max<gH323ep.udpPorts.start)
+   {
+      OOTRACEERR1("Error: Failed to set udp ports- Max port number"
+                  " less than Start port number\n");
+      return OO_FAILED;
+   }
+        
+   gH323ep.udpPorts.current = gH323ep.udpPorts.start;
+        
+   OOTRACEINFO1("UDP port range initialize - successful\n");
+
+   return OO_OK;
+}
+
+int ooH323EpSetRTPPortRange(int base, int max)
+{
+   if(base <= 1024)
+      gH323ep.rtpPorts.start = 1025;
+   else
+      gH323ep.rtpPorts.start = base;
+   if(max > 65500)
+      gH323ep.rtpPorts.max = 65500;
+   else 
+      gH323ep.rtpPorts.max = max;
+        
+   if(gH323ep.rtpPorts.max<gH323ep.rtpPorts.start)
+   {
+      OOTRACEERR1("Error: Failed to set rtp ports- Max port number"
+                  " less than Start port number\n");
+      return OO_FAILED;
+   }
+        
+   gH323ep.rtpPorts.current = gH323ep.rtpPorts.start;
+   OOTRACEINFO1("RTP port range initialize - successful\n");
+   return OO_OK;
+}
+
diff --git a/addons/ooh323c/src/ooh323ep.h b/addons/ooh323c/src/ooh323ep.h
new file mode 100644
index 000000000..9d80a1df1
--- /dev/null
+++ b/addons/ooh323c/src/ooh323ep.h
@@ -0,0 +1,634 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file ooh323ep.h 
+ * This file contains H323 endpoint related functions. 
+ */
+#ifndef OO_H323EP_H_
+#define OO_H323EP_H_
+#include "ooCapability.h"
+#include "ooCalls.h"
+#include "ooGkClient.h"
+#include "ooports.h"
+#include "ooq931.h"
+
+#define DEFAULT_TRACEFILE "trace.log"
+#define DEFAULT_TERMTYPE 50
+#define DEFAULT_PRODUCTID  "objsys"
+#define DEFAULT_CALLERID   "objsyscall"
+#define DEFAULT_T35COUNTRYCODE 1
+#define DEFAULT_T35EXTENSION 0
+#define DEFAULT_MANUFACTURERCODE 71
+#define DEFAULT_H245CONNECTION_RETRYTIMEOUT 2
+#define DEFAULT_CALLESTB_TIMEOUT 60
+#define DEFAULT_MSD_TIMEOUT 30
+#define DEFAULT_TCS_TIMEOUT 30
+#define DEFAULT_LOGICALCHAN_TIMEOUT 30
+#define DEFAULT_ENDSESSION_TIMEOUT 15
+#define DEFAULT_H323PORT 1720
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+struct OOCapPrefs;
+/** 
+ * @defgroup h323ep  H323 Endpoint management functions
+ * @{
+ */
+/* Default port ranges */
+#define TCPPORTSSTART 12030  /*!< Starting TCP port number */
+#define TCPPORTSEND   12230  /*!< Ending TCP port number   */
+#define UDPPORTSSTART 13030  /*!< Starting UDP port number */
+#define UDPPORTSEND   13230  /*!< Ending UDP port number   */
+#define RTPPORTSSTART 14030  /*!< Starting RTP port number */
+#define RTPPORTSEND   14230  /*!< Ending RTP port number   */
+
+
+
+  
+/**
+ * This structure is used to define the port ranges to be used
+ * by the application.
+ */
+typedef struct OOH323Ports {
+   int start;    /*!< Starting port number. */
+   int max;      /*!< Maximum port number.  */
+   int current;  /*!< Current port number.  */
+} OOH323Ports;
+
+/** 
+ * Structure to store all configuration information related to the
+ * endpoint created by an application 
+ */
+typedef struct OOH323EndPoint {
+   
+   /** 
+    * This context should be used for allocation of memory for
+    * items within the endpoint structure.
+    */
+   OOCTXT ctxt;
+
+   /** 
+    * This context should be used for allocation of memory for
+    * message structures.
+    */
+   OOCTXT msgctxt;
+
+   char   traceFile[MAXFILENAME];
+   FILE * fptraceFile;
+
+   /** Range of port numbers to be used for TCP connections */
+   OOH323Ports tcpPorts;
+
+   /** Range of port numbers to be used for UDP connections */
+   OOH323Ports udpPorts;
+
+   /** Range of port numbers to be used for RTP connections */
+   OOH323Ports rtpPorts;
+  
+   ASN1UINT  flags;
+
+   int termType; /* 50 - Terminal entity with No MC, 
+                    60 - Gateway entity with no MC, 
+                    70 - Terminal Entity with MC, but no MP etc.*/
+   int t35CountryCode;
+   int t35Extension;
+   int manufacturerCode;
+   const char *productID;
+   const char *versionID;
+   const char *callerid;
+   char callingPartyNumber[50];
+   OOSOCKET *stackSocket;
+   OOAliases *aliases;
+
+   int callType;
+
+   struct ooH323EpCapability *myCaps;
+   OOCapPrefs     capPrefs;
+   int noOfCaps;
+   OOH225MsgCallbacks h225Callbacks;
+   OOH323CALLBACKS h323Callbacks;
+   char signallingIP[20];
+   int listenPort;
+   OOSOCKET *listener;
+   OOH323CallData *callList;
+
+   OOCallMode callMode; /* audio/audiorx/audiotx/video/fax */
+   int dtmfmode;
+   ASN1UINT callEstablishmentTimeout;
+   ASN1UINT msdTimeout;
+   ASN1UINT tcsTimeout;
+   ASN1UINT logicalChannelTimeout;
+   ASN1UINT sessionTimeout;
+   int cmdPipe[2];
+   struct ooGkClient *gkClient;
+
+   OOInterface *ifList; /* interface list for the host we are running on*/
+   OOBOOL isGateway;
+   OOSOCKET cmdSock;
+} OOH323EndPoint;
+
+#define ooEndPoint OOH323EndPoint
+
+/**
+ * This function is the first function to be invoked before using stack. It
+ * initializes the H323 Endpoint.
+ * @param callMode       Type of calls to be made(audio/video/fax).
+ *                       (OO_CALLMODE_AUDIO, OO_CALLMODE_VIDEO)
+ * @param tracefile      Trace file name.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooH323EpInitialize
+   (enum OOCallMode callMode, const char* tracefile);
+
+/**
+ * This function is used to represent the H.323 application endpoint as 
+ * gateway, instead of an H.323 phone endpoint.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpSetAsGateway();
+
+/**
+ * This function is used to assign a local ip address to be used for call
+ * signalling.
+ * @param localip        Dotted IP address to be used for call signalling.
+ * @param listenport     Port to be used for listening for incoming calls.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */ 
+EXTERN int ooH323EpSetLocalAddress(const char* localip, int listenport);
+
+/**
+ * This function is used to set the range of tcp ports the application will
+ * use for tcp transport.
+ * @param base           Starting port number for the range
+ * @param max            Ending port number for the range.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.    
+ */
+EXTERN int ooH323EpSetTCPPortRange(int base, int max);
+
+/**
+ * This function is used to set the range of udp ports the application will
+ * use for udp transport.
+ * @param base           Starting port number for the range
+ * @param max            Ending port number for the range.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.    
+ */
+EXTERN int ooH323EpSetUDPPortRange(int base, int max);
+
+/**
+ * This function is used to set the range of rtp ports the application will
+ * use for media streams.
+ * @param base           Starting port number for the range
+ * @param max            Ending port number for the range.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.    
+ */
+EXTERN int ooH323EpSetRTPPortRange(int base, int max);
+
+/**
+ * This function is used to set the trace level for the H.323 endpoint.
+ * @param traceLevel     Level of tracing.
+ *
+ * @return               OO_OK, on success. OO_FAILED, otherwise.
+ */
+EXTERN int ooH323EpSetTraceLevel(int traceLevel);
+
+/**
+ * This function is used to add the h323id alias for the endpoint.
+ * @param h323id         H323-ID to be set as alias.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpAddAliasH323ID(const char* h323id);
+
+/**
+ * This function is used to add the dialed digits alias for the
+ * endpoint.
+ * @param dialedDigits   Dialed-Digits to be set as alias.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpAddAliasDialedDigits(const char* dialedDigits);
+
+/**
+ * This function is used to add the url alias for the endpoint.
+ * @param url            URL to be set as an alias.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpAddAliasURLID(const char* url);
+
+/**
+ * This function is used to add an email id as an alias for the endpoint.
+ * @param email          Email id to be set as an alias.
+ * 
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpAddAliasEmailID(const char* email);
+
+/**
+ * This function is used to add an ip address as an alias.
+ * @param ipaddress      IP address to be set as an alias.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpAddAliasTransportID(const char* ipaddress);
+
+/**
+ * This function is used to clear all the aliases used by the 
+ * H323 endpoint.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpClearAllAliases(void);
+
+/**
+ * This function is used to set the H225 message callbacks for the
+ * endpoint.
+ * @param h225Callbacks  Callback structure containing various callbacks.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpSetH225MsgCallbacks(OOH225MsgCallbacks h225Callbacks);
+
+/**
+ * This function is used to set high level H.323 callbacks for the endpoint.
+ * Make sure all unused callbacks in the structure are set to NULL before 
+ * calling this function.
+ * @param h323Callbacks    Callback structure containing various high level 
+ *                         callbacks.
+ * @return                 OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooH323EpSetH323Callbacks(OOH323CALLBACKS h323Callbacks);
+
+
+/**
+ * This function is the last function to be invoked after done using the 
+ * stack. It closes the H323 Endpoint for an application, releasing all 
+ * the associated memory.
+ *
+ * @return          OO_OK on success
+ *                  OO_FAILED on failure
+ */
+EXTERN int ooH323EpDestroy(void);
+
+
+/**
+ * This function is used to enable the auto answer feature for
+ * incoming calls
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpEnableAutoAnswer(void);
+
+/**
+ * This function is used to disable the auto answer feature for
+ * incoming calls.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpDisableAutoAnswer(void);
+
+/**
+ * This function is used to enable manual ringback. By default the stack sends 
+ * alerting message automatically on behalf of the endpoint application. 
+ * However, if endpoint application wants to do alerting user part first before
+ * sending out alerting message, it can enable this feature.
+ *
+ * @return          OO_OK on success, OO_FAILED on failure
+ */
+EXTERN int ooH323EpEnableManualRingback(void);
+
+/**
+ * This function is used to disable manual ringback. By default the 
+ * manual ringback feature is disabled, i.e, the stack sends alerting on behalf
+ * of the application automatically.
+ *
+ * @return          OO_OK on success, OO_FAILED on failure
+ */
+EXTERN int ooH323EpDisableManualRingback(void);
+
+/**
+ * This function is used to enable MediaWaitForConnect.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpDisableMediaWaitForConnect(void);
+
+/**
+ * This function is used to disable MediaWaitForConnect.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpDisableMediaWaitForConnect(void);
+
+/**
+ * This function is used to enable faststart.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpEnableFastStart(void);
+
+/**
+ * This function is used to disable faststart.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpDisableFastStart(void);
+
+/**
+ * This function is used to enable tunneling.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpEnableH245Tunneling(void);
+
+/**
+ * This function is used to disable tunneling.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpDisableH245Tunneling(void);
+
+/**
+ * This function is used to enable GkRouted calls.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpEnableGkRouted(void);
+
+/**
+ * This function is used to disable Gkrouted calls.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpDisableGkRouted(void);
+
+/**
+ * This function is used to set the product ID.
+ * @param productID  New value for the product id.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */ 
+EXTERN int ooH323EpSetProductID (const char * productID);
+
+/**
+ * This function is used to set version id.
+ * @param versionID  New value for the version id.
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpSetVersionID (const char * versionID);
+
+/**
+ * This function is used to set callerid to be used for outbound
+ * calls.
+ * @param callerID  New value for the caller id.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpSetCallerID (const char * callerID);
+
+/**
+ * This function is used to set calling party number to be used for outbound
+ * calls.Note, you can override it for a specific call by using 
+ * ooCallSetCallingPartyNumber function.
+ * @param number   e164 number to be used as calling party number.
+ *
+ * @return         OO_OK, on success; OO_FAILED, otherwise.
+ */
+EXTERN int ooH323EpSetCallingPartyNumber(const char * number);
+
+/**
+ * This function is used to print the current configuration information of 
+ * the H323 endpoint to log file.
+ */
+void ooH323EpPrintConfig(void);
+
+
+/**
+ * This function is used to add G728 capability to the H323 endpoint.
+ * @param cap                  Type of G728 capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooH323EpAddG728Capability
+   (int cap, int txframes, int rxframes, int dir, 
+    cb_StartReceiveChannel startReceiveChannel,
+    cb_StartTransmitChannel startTransmitChannel,
+    cb_StopReceiveChannel stopReceiveChannel,
+    cb_StopTransmitChannel stopTransmitChannel);
+
+/**
+ * This function is used to add G729 capability to the H323 endpoint.
+ * @param cap                  Type of G729 capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooH323EpAddG729Capability
+   (int cap, int txframes, int rxframes, int dir, 
+    cb_StartReceiveChannel startReceiveChannel,
+    cb_StartTransmitChannel startTransmitChannel,
+    cb_StopReceiveChannel stopReceiveChannel,
+    cb_StopTransmitChannel stopTransmitChannel);
+
+
+/**
+ * This function is used to add G7231 capability to the H323 endpoint.
+ * @param cap                  Type of G7231 capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param silenceSuppression   Silence Suppression support
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooH323EpAddG7231Capability(int cap, int txframes, int rxframes, 
+                              OOBOOL silenceSuppression, int dir,
+                              cb_StartReceiveChannel startReceiveChannel,
+                              cb_StartTransmitChannel startTransmitChannel,
+                              cb_StopReceiveChannel stopReceiveChannel,
+                              cb_StopTransmitChannel stopTransmitChannel);
+
+/**
+ * This function is used to add G711 capability to the H323 endpoint.
+ * @param cap                  Type of G711 capability to be added.
+ * @param txframes             Number of frames per packet for transmission. 
+ * @param rxframes             Number of frames per packet for reception.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooH323EpAddG711Capability
+   (int cap, int txframes, int rxframes, int dir, 
+    cb_StartReceiveChannel startReceiveChannel,
+    cb_StartTransmitChannel startTransmitChannel,
+    cb_StopReceiveChannel stopReceiveChannel,
+    cb_StopTransmitChannel stopTransmitChannel);
+
+
+/**
+ * This function is used to add a new GSM capability to the endpoint.
+ * @param cap                  Type of GSM capability to be added.
+ * @param framesPerPkt         Number of GSM frames pre packet. 
+ * @param comfortNoise         Comfort noise spec for the capability. 
+ * @param scrambled            Scrambled enabled/disabled for the capability.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooH323EpAddGSMCapability(int cap, ASN1USINT framesPerPkt, 
+                             OOBOOL comfortNoise,OOBOOL scrambled,int dir, 
+                             cb_StartReceiveChannel startReceiveChannel,
+                             cb_StartTransmitChannel startTransmitChannel,
+                             cb_StopReceiveChannel stopReceiveChannel,
+                             cb_StopTransmitChannel stopTransmitChannel);
+/**
+ * This function is used to add H263 video capability to the H323 endpoint.
+ * @param cap                  Capability type - OO_H263VIDEO
+ * @param sqcifMPI             Minimum picture interval for encoding/decoding 
+ *                             of SQCIF pictures.
+ * @param qcifMPI              Minimum picture interval for encoding/decoding 
+ *                             of QCIF pictures.
+ * @param cifMPI               Minimum picture interval for encoding/decoding 
+ *                             of CIF pictures.
+ * @param cif4MPI              Minimum picture interval for encoding/decoding 
+ *                             of CIF4 pictures.
+ * @param cif16MPI             Minimum picture interval for encoding/decoding 
+ *                             of CIF16 pictures.
+ * @param maxBitRate           Maximum bit rate in units of 100 bits/s at
+ *                             which a transmitter can transmit video or a 
+ *                             receiver can receive video.
+ * @param dir                  Direction of capability.OORX, OOTX, OORXANDTX
+ * @param startReceiveChannel  Callback function to start receive channel.
+ * @param startTransmitChannel Callback function to start transmit channel.
+ * @param stopReceiveChannel   Callback function to stop receive channel.
+ * @param stopTransmitChannel  Callback function to stop transmit channel.
+ *
+ * @return                     OO_OK, on success. OO_FAILED, on failure. 
+ */
+EXTERN int ooH323EpAddH263VideoCapability(int cap, unsigned sqcifMPI, 
+                                 unsigned qcifMPI, unsigned cifMPI, 
+                                 unsigned cif4MPI, unsigned cif16MPI, 
+                                 unsigned maxBitRate, int dir, 
+                                 cb_StartReceiveChannel startReceiveChannel,
+                                 cb_StartTransmitChannel startTransmitChannel,
+                                 cb_StopReceiveChannel stopReceiveChannel,
+                                 cb_StopTransmitChannel stopTransmitChannel);
+
+/**
+ * This function is used to enable rfc 2833 support for the endpoint.
+ * @param dynamicRTPPayloadType   Payload type value to use.
+ *
+ * @return                        OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooH323EpEnableDTMFRFC2833(int dynamicRTPPayloadType);
+
+/**
+ * This function is used to disable rfc 2833 support for the endpoint.
+ *
+ * @return                        OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooH323EpDisableDTMFRFC2833(void);
+
+/**
+ * This function is used to enable the H245(alphanumeric) dtmf capability for
+ * the endpoint.
+ * @return                        OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooH323EpEnableDTMFH245Alphanumeric();
+
+/**
+ * This function is used to disable the H245(alphanumeric) dtmf capability for
+ * the endpoint.
+ * @return                        OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooH323EpDisableDTMFH245Alphanumeric();
+
+/**
+ * This function is used to enable the H245(signal) dtmf capability for
+ * the endpoint.
+ * @return                        OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooH323EpEnableDTMFH245Signal();
+
+/**
+ * This function is used to disable the H245(signal) dtmf capability for
+ * the endpoint.
+ * @return                        OO_OK, on success; OO_FAILED, on failure
+ */
+EXTERN int ooH323EpDisableDTMFH245Signal();
+
+/**
+ * This function is used to add callbacks to the gatekeeper client. If user
+ * application wants to do some special processing of various gatekeeper client
+ * events, that can be done through these callbacks.
+ * @param gkClientCallbacks      Handle to the callback structure.Make sure all
+ *                               the members of the structure are appropriately
+ *                               initialized.
+ *
+ * @return                       OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323EpSetGkClientCallbacks(OOGKCLIENTCALLBACKS gkClientCallbacks);
+
+/**
+ * @}
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/oohdr.h b/addons/ooh323c/src/oohdr.h
new file mode 100644
index 000000000..b7f9590c9
--- /dev/null
+++ b/addons/ooh323c/src/oohdr.h
@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
diff --git a/addons/ooh323c/src/ooper.h b/addons/ooh323c/src/ooper.h
new file mode 100644
index 000000000..6a1174a2b
--- /dev/null
+++ b/addons/ooh323c/src/ooper.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#ifndef _OOPER_H_
+#define _OOPER_H_
+
+
+#endif
+
diff --git a/addons/ooh323c/src/ooports.c b/addons/ooh323c/src/ooports.c
new file mode 100644
index 000000000..3059404db
--- /dev/null
+++ b/addons/ooh323c/src/ooports.c
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+
+#include "ooports.h"
+#include "ooh323ep.h"
+#include "ootrace.h"
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+/* Get the next port of type TCP/UDP/RTP */
+int ooGetNextPort (OOH323PortType type)
+{
+   if(type==OOTCP)
+   {
+      if(gH323ep.tcpPorts.current <= gH323ep.tcpPorts.max)
+         return gH323ep.tcpPorts.current++;
+      else
+      {
+         gH323ep.tcpPorts.current = gH323ep.tcpPorts.start;
+         return gH323ep.tcpPorts.current++;
+      }
+   }
+   if(type==OOUDP)
+   {
+      if(gH323ep.udpPorts.current <= gH323ep.udpPorts.max)
+         return gH323ep.udpPorts.current++;
+      else
+      {
+         gH323ep.udpPorts.current = gH323ep.udpPorts.start;
+         return gH323ep.udpPorts.current++;
+      }
+   }
+   if(type==OORTP)
+   {
+      if(gH323ep.rtpPorts.current <= gH323ep.rtpPorts.max)
+         return gH323ep.rtpPorts.current++;
+      else
+      {
+         gH323ep.rtpPorts.current = gH323ep.rtpPorts.start;
+         return gH323ep.rtpPorts.current++;
+      }
+   }
+   return OO_FAILED;
+}
+
+int ooBindPort (OOH323PortType type, OOSOCKET socket, char *ip)
+{
+   int initialPort, bindPort, ret;
+   OOIPADDR ipAddrs;
+
+   initialPort = ooGetNextPort (type);
+   bindPort = initialPort;
+
+   ret= ooSocketStrToAddr (ip, &ipAddrs);
+
+   while(1)
+   {
+      if((ret=ooSocketBind(socket, ipAddrs, bindPort))==0)
+      {
+         return bindPort;
+      }
+      else
+      {
+         bindPort = ooGetNextPort (type);
+         if (bindPort == initialPort) return OO_FAILED;
+      }
+   }
+}
+
+#ifdef _WIN32        
+int ooBindOSAllocatedPort(OOSOCKET socket, char *ip)
+{
+   OOIPADDR ipAddrs;
+   int size, ret;
+   struct sockaddr_in name;
+   size = sizeof(struct sockaddr_in);
+   ret= ooSocketStrToAddr (ip, &ipAddrs);
+   if((ret=ooSocketBind(socket, ipAddrs, 
+                     0))==ASN_OK)
+   {
+      ret = ooSocketGetSockName(socket, &name, &size);
+      if(ret == ASN_OK)
+      {
+         return name.sin_port;
+         
+      }
+   }
+
+   return OO_FAILED;
+}
+#endif
diff --git a/addons/ooh323c/src/ooports.h b/addons/ooh323c/src/ooports.h
new file mode 100644
index 000000000..0b53e8af8
--- /dev/null
+++ b/addons/ooh323c/src/ooports.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/**
+ * @file ooports.h 
+ * This file contains functions to manage ports used by the stack. 
+ */
+
+#ifndef _OOPORTS_H_
+#define _OOPORTS_H_
+
+#include "ootypes.h"
+
+typedef enum OOH323PortType {
+   OOTCP, OOUDP, OORTP
+} OOH323PortType;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+/**
+ * Get the next port of type TCP/UDP/RTP from the corresponding range.
+ * When max value for the range is reached, it starts again from the 
+ * first port number of the range.
+ *
+ * @param ep         Reference to the H323 Endpoint structure.
+ * @param type       Type of the port to be retrieved(OOTCP/OOUDP/OORTP).
+ *
+ * @return           The next port number for the specified type is returned.
+ */
+EXTERN int ooGetNextPort (OOH323PortType type);
+
+/**
+ * Bind socket to a port within the port range specified by the
+ * application at the startup.
+ *
+ * @param ep        Reference to H323 Endpoint structure.
+ * @param type      Type of the port required for the socket.
+ * @param socket    The socket to be bound.
+ * @param ip        Dotted Ip address to bind to.
+ *
+ * @return          In case of success returns the port number to which
+ *                  socket is bound and in case of failure just returns
+ *                  a negative value.
+*/
+EXTERN int ooBindPort (OOH323PortType type, OOSOCKET socket, char *ip);
+
+/**
+ * This function is supported for windows version only. 
+ *  Windows sockets have problem in reusing the addresses even after
+ *  setting SO_REUSEADDR, hence in windows we just allow os to bind
+ *  to any random port.
+ * @param socket    Socket to be bound.
+ * @param ip        Dotted ip address to bind to.
+ *
+ * @return          In case of success returns the port number to which
+ *                  socket is bound and in case of failure just returns
+ *                  a negative value.
+ */
+#ifdef _WIN32        
+EXTERN int ooBindOSAllocatedPort(OOSOCKET socket, char *ip);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/addons/ooh323c/src/ooq931.c b/addons/ooh323c/src/ooq931.c
new file mode 100644
index 000000000..e440b4c7b
--- /dev/null
+++ b/addons/ooh323c/src/ooq931.c
@@ -0,0 +1,3448 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooq931.h"
+#include "ootrace.h"
+#include "ooasn1.h"
+#include "oochannels.h"
+#include "printHandler.h"
+#include "ooCalls.h"
+#include "ooh323.h"
+#include "ooh245.h"
+#include "ooh323ep.h"
+#include "ooCapability.h"
+#include "ooGkClient.h"
+#include "ooUtils.h"
+#include "ootypes.h"
+#include <time.h>
+#include <ctype.h>
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+
+static ASN1OBJID gProtocolID = {
+   6, { 0, 0, 8, 2250, 0, 4 }
+};
+
+EXTERN int ooQ931Decode 
+   (OOH323CallData *call, Q931Message* msg, int length, ASN1OCTET *data) 
+{
+   int offset, x;
+   int rv = ASN_OK;
+   char number[128];
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   dListInit (&msg->ies); /* clear information elements list */
+
+   if (length < 5)  /* Packet too short */
+      return Q931_E_TOOSHORT;
+
+   msg->protocolDiscriminator = data[0];
+   OOTRACEDBGB2("   protocolDiscriminator = %d\n", msg->protocolDiscriminator);
+   if (data[1] != 2) /* Call reference must be 2 bytes long */
+      return Q931_E_INVCALLREF;
+
+   msg->callReference = ((data[2] & 0x7f) << 8) | data[3];
+
+   OOTRACEDBGB2("   callReference = %d\n", msg->callReference);
+
+   msg->fromDestination = (data[2] & 0x80) != 0;
+   if(msg->fromDestination)
+      OOTRACEDBGB1("   from = destination\n");
+   else
+      OOTRACEDBGB1("   from = originator\n");   
+
+
+   msg->messageType = data[4];
+   OOTRACEDBGB2("   messageType = %x\n", msg->messageType);
+
+   
+   /* Have preamble, start getting the informationElements into buffers */
+   offset = 5;
+   while (offset < length) {
+      Q931InformationElement *ie;
+      int ieOff = offset;
+      /* Get field discriminator */
+      int discriminator = data[offset++];
+
+      /* For discriminator with high bit set there is no data */
+      if ((discriminator & 0x80) == 0) {
+         int len = data[offset++], alen;
+
+         if (discriminator == Q931UserUserIE) {
+            /* Special case of User-user field, there is some confusion here as
+               the Q931 documentation claims the length is a single byte,
+               unfortunately all H.323 based apps have a 16 bit length here, so
+               we allow for said longer length. There is presumably an addendum
+               to Q931 which describes this, and provides a means to 
+               discriminate between the old 1 byte and the new 2 byte systems. 
+               However, at present we assume it is always 2 bytes until we find
+               something that breaks it. 
+            */
+            len <<= 8;
+            len |= data[offset++];
+
+            /* we also have a protocol discriminator, which we ignore */
+            offset++;
+            len--;
+         }
+
+         /* watch out for negative lengths! (ED, 11/5/03) */
+         if (len < 0) {
+            return Q931_E_INVLENGTH;
+         }
+         else if (offset + len > length) {
+            alen = 0;
+            len = -len;
+            rv = Q931_E_INVLENGTH;
+         }
+         else alen = len;
+
+         ie = (Q931InformationElement*) 
+            memAlloc (pctxt, sizeof(*ie) - sizeof(ie->data) + alen);
+         if(!ie)
+         {
+            OOTRACEERR3("Error:Memory - ooQ931Decode - ie(%s, %s)\n", 
+                         call->callType, call->callToken);
+            return OO_FAILED;
+         }
+         ie->discriminator = discriminator;
+         ie->offset = ieOff;
+         ie->length = len;
+         if (alen != 0) 
+            memcpy(ie->data, data + offset, alen);
+         offset += len;
+      }
+      else {
+         ie = (Q931InformationElement*) memAlloc (pctxt, 
+                                        sizeof(*ie) - sizeof(ie->data));
+         if(!ie)
+         {
+            OOTRACEERR3("Error:Memory - ooQ931Decode - ie(%s, %s)\n", 
+                         call->callType, call->callToken);
+            return OO_FAILED;
+         }
+         ie->discriminator = discriminator;
+         ie->offset = offset;
+         ie->length = 0;
+      }
+      if(ie->discriminator == Q931BearerCapabilityIE)
+      {
+         OOTRACEDBGB1("   Bearer-Capability IE = {\n");
+         for(x=0; x<ie->length; x++)
+         {
+            if(x==0)
+               OOTRACEDBGB2("      %x", ie->data[x]);
+            else
+               OOTRACEDBGB2(", %x", ie->data[x]);
+         }
+         OOTRACEDBGB1("   }\n");
+      }
+      if(ie->discriminator == Q931DisplayIE)
+      {
+         OOTRACEDBGB1("   Display IE = {\n");
+         OOTRACEDBGB2("      %s\n", ie->data);
+         OOTRACEDBGB1("   }\n");
+      }
+
+      if(ie->discriminator == Q931KeypadIE)
+      {
+         OOTRACEDBGB1("   Keypad IE = {\n");
+         OOTRACEDBGB2("      %s\n", ie->data);
+         OOTRACEDBGB1("   }\n");
+         if(gH323ep.h323Callbacks.onReceivedDTMF)
+         {
+            gH323ep.h323Callbacks.onReceivedDTMF(call, ie->data);
+         }
+      }
+      /* Extract calling party number TODO:Give respect to presentation and 
+         screening indicators ;-) */
+      if(ie->discriminator == Q931CallingPartyNumberIE)
+      {
+         OOTRACEDBGB1("   CallingPartyNumber IE = {\n");
+         if(ie->length < OO_MAX_NUMBER_LENGTH)
+         {
+            int numoffset=1; 
+            if(!(0x80 & ie->data[0])) numoffset = 2;
+            memcpy(number, ie->data+numoffset,ie->length-numoffset);
+            number[ie->length-numoffset]='\0';
+            OOTRACEDBGB2("      %s\n", number);
+            if(!call->callingPartyNumber)
+               ooCallSetCallingPartyNumber(call, number);
+         }
+         else{
+            OOTRACEERR3("Error:Calling party number too long. (%s, %s)\n", 
+                           call->callType, call->callToken);
+         }
+         OOTRACEDBGB1("   }\n");
+      }
+
+      /* Extract called party number */
+      if(ie->discriminator == Q931CalledPartyNumberIE)
+      {
+         OOTRACEDBGB1("   CalledPartyNumber IE = {\n");
+         if(ie->length < OO_MAX_NUMBER_LENGTH)
+         {
+            memcpy(number, ie->data+1,ie->length-1);
+            number[ie->length-1]='\0';
+            OOTRACEDBGB2("      %s\n", number);
+            if(!call->calledPartyNumber)
+               ooCallSetCalledPartyNumber(call, number);
+         }
+         else{
+            OOTRACEERR3("Error:Calling party number too long. (%s, %s)\n", 
+                           call->callType, call->callToken);
+         }
+         OOTRACEDBGB1("   }\n");
+      }
+
+      /* Handle Cause ie */
+      if(ie->discriminator == Q931CauseIE)
+      {
+         msg->causeIE = ie;
+         OOTRACEDBGB1("   Cause IE = {\n");
+         OOTRACEDBGB2("      %s\n", ooGetQ931CauseValueText(ie->data[1]&0x7f));
+         OOTRACEDBGB1("   }\n");
+      }
+
+      /* TODO: Get rid of ie list.*/
+      dListAppend (pctxt, &msg->ies, ie);
+      if (rv != ASN_OK)
+         return rv;
+   }
+   
+   /*cisco router sends Q931Notify without UU ie, 
+     we just ignore notify message as of now as handling is optional for
+     end point*/
+   if(msg->messageType != Q931NotifyMsg)
+      rv = ooDecodeUUIE(msg);
+   return rv;
+}
+
+EXTERN Q931InformationElement* ooQ931GetIE (const Q931Message* q931msg, 
+                                              int ieCode)
+{
+   DListNode* curNode;
+   unsigned int i;
+
+   for(i = 0, curNode = q931msg->ies.head; i < q931msg->ies.count; i++) {
+      Q931InformationElement *ie = (Q931InformationElement*) curNode->data;
+      if (ie->discriminator == ieCode) {
+         return ie;
+      }
+      curNode = curNode->next;
+   }
+   return NULL;
+}
+
+char* ooQ931GetMessageTypeName(int messageType, char* buf) {
+   switch (messageType) {
+      case Q931AlertingMsg :
+         strcpy(buf, "Alerting");
+         break;
+      case Q931CallProceedingMsg :
+         strcpy(buf, "CallProceeding");
+         break;
+      case Q931ConnectMsg :
+         strcpy(buf, "Connect");
+         break;
+      case Q931ConnectAckMsg :
+         strcpy(buf, "ConnectAck");
+         break;
+      case Q931ProgressMsg :
+         strcpy(buf, "Progress");
+         break;
+      case Q931SetupMsg :
+         strcpy(buf, "Setup");
+         break;
+      case Q931SetupAckMsg :
+         strcpy(buf, "SetupAck");
+         break;
+      case Q931FacilityMsg :
+         strcpy(buf, "Facility");
+         break;
+      case Q931ReleaseCompleteMsg :
+         strcpy(buf, "ReleaseComplete");
+         break;
+      case Q931StatusEnquiryMsg :
+         strcpy(buf, "StatusEnquiry");
+         break;
+      case Q931StatusMsg :
+         strcpy(buf, "Status");
+         break;
+      case Q931InformationMsg :
+         strcpy(buf, "Information");
+         break;
+      case Q931NationalEscapeMsg :
+         strcpy(buf, "Escape");
+         break;
+      default:
+         sprintf(buf, "<%u>", messageType);
+   }
+   return buf;
+}
+
+char* ooQ931GetIEName(int number, char* buf) {
+   switch (number) {
+      case Q931BearerCapabilityIE :
+         strcpy(buf, "Bearer-Capability");
+         break;
+      case Q931CauseIE :
+         strcpy(buf, "Cause");
+         break;
+      case Q931FacilityIE :
+         strcpy(buf, "Facility");
+         break;
+      case Q931ProgressIndicatorIE :
+         strcpy(buf, "Progress-Indicator");
+         break;
+      case Q931CallStateIE :
+         strcpy(buf, "Call-State");
+         break;
+      case Q931DisplayIE :
+         strcpy(buf, "Display");
+         break;
+      case Q931SignalIE :
+         strcpy(buf, "Signal");
+         break;
+      case Q931CallingPartyNumberIE :
+         strcpy(buf, "Calling-Party-Number");
+         break;
+      case Q931CalledPartyNumberIE :
+         strcpy(buf, "Called-Party-Number");
+         break;
+      case Q931RedirectingNumberIE :
+         strcpy(buf, "Redirecting-Number");
+         break;
+      case Q931UserUserIE :
+         strcpy(buf, "User-User");
+         break;
+      default:
+         sprintf(buf, "0x%02x", number);
+   }
+   return buf;
+}
+
+EXTERN void ooQ931Print (const Q931Message* q931msg) {
+   char buf[1000];
+   DListNode* curNode;
+   unsigned int i;
+
+   printf("Q.931 Message:\n");
+   printf("   protocolDiscriminator: %i\n", q931msg->protocolDiscriminator);
+   printf("   callReference: %i\n", q931msg->callReference);
+   printf("   from: %s\n", (q931msg->fromDestination ? 
+                                       "destination" : "originator"));
+   printf("   messageType: %s (0x%X)\n\n", 
+              ooQ931GetMessageTypeName(q931msg->messageType, buf), 
+                                               q931msg->messageType);
+
+   for(i = 0, curNode = q931msg->ies.head; i < q931msg->ies.count; i++) {
+      Q931InformationElement *ie = (Q931InformationElement*) curNode->data;
+      int length = (ie->length >= 0) ? ie->length : -ie->length;
+      printf("   IE[%i] (offset 0x%X):\n", i, ie->offset);
+      printf("      discriminator: %s (0x%X)\n", 
+               ooQ931GetIEName(ie->discriminator, buf), ie->discriminator);
+      printf("      data length: %i\n", length);
+ 
+      curNode = curNode->next;
+      printf("\n");
+   }
+}
+
+int ooCreateQ931Message(Q931Message **q931msg, int msgType)
+{
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   
+   *q931msg = (Q931Message*)memAllocZ(pctxt, sizeof(Q931Message));
+                
+   if(!*q931msg)
+   {
+      OOTRACEERR1("Error:Memory -  ooCreateQ931Message - q931msg\n");
+      return OO_FAILED;
+   }
+   else
+   {
+      (*q931msg)->protocolDiscriminator = 8;
+      (*q931msg)->fromDestination = FALSE;
+      (*q931msg)->messageType = msgType;
+      (*q931msg)->tunneledMsgType = msgType;
+      (*q931msg)->logicalChannelNo = 0;
+      (*q931msg)->bearerCapabilityIE = NULL;
+      (*q931msg)->callingPartyNumberIE = NULL;
+      (*q931msg)->calledPartyNumberIE = NULL;
+      (*q931msg)->causeIE = NULL;
+      return OO_OK;
+   }
+}
+
+
+int ooGenerateCallToken (char *callToken, size_t size)
+{
+   static int counter = 1;
+   char aCallToken[200];
+   int  ret = 0;
+
+   sprintf (aCallToken, "ooh323c_%d", counter++);
+
+   if (counter > OO_MAX_CALL_TOKEN)
+      counter = 1;
+
+   if ((strlen(aCallToken)+1) < size)
+      strcpy (callToken, aCallToken);
+   else {
+      OOTRACEERR1 ("Error: Insufficient buffer size to generate call token");
+      ret = OO_FAILED;
+   }
+
+
+   return ret;
+}
+
+/* CallReference is a two octet field, thus max value can be 0xffff
+   or 65535 decimal. We restrict max value to 32760, however, this should
+   not cause any problems as there won't be those many simultaneous calls
+   CallRef has to be locally unique and generated by caller.
+*/
+ASN1USINT ooGenerateCallReference()
+{
+   static ASN1USINT lastCallRef=0;
+   ASN1USINT newCallRef=0;
+
+
+   if(lastCallRef == 0)
+   {
+      /* Generate a new random callRef */
+      srand((unsigned)time(0));
+      lastCallRef = (ASN1USINT)(rand()%100);
+   }
+   else
+      lastCallRef++;
+
+   /* Note callReference can be at the most 15 bits that is from 0 to 32767.
+      if we generate number bigger than that, bring it in range.
+   */
+   if(lastCallRef>=32766)
+      lastCallRef=1;
+
+   newCallRef = lastCallRef;
+
+
+   OOTRACEDBGC2("Generated callRef %d\n", newCallRef);
+   return newCallRef;
+}
+
+
+int ooGenerateCallIdentifier(H225CallIdentifier *callid)
+{
+   ASN1INT64 timestamp;
+   int i=0;
+#ifdef _WIN32
+   
+   SYSTEMTIME systemTime;
+   GetLocalTime(&systemTime);
+   SystemTimeToFileTime(&systemTime, (LPFILETIME)&timestamp);
+#else
+   struct timeval systemTime;
+   gettimeofday(&systemTime, NULL);
+   timestamp = systemTime.tv_sec * 10000000 + systemTime.tv_usec*10;
+#endif
+
+   callid->guid.numocts = 16;
+   callid->guid.data[0] = 'o';
+   callid->guid.data[1] = 'o';
+   callid->guid.data[2] = 'h';
+   callid->guid.data[3] = '3';
+   callid->guid.data[4] = '2';
+   callid->guid.data[5] = '3';
+   callid->guid.data[6] = 'c';
+   callid->guid.data[7] = '-';
+
+   for (i = 8; i < 16; i++)
+       callid->guid.data[i] = (ASN1OCTET)((timestamp>>((i-8+1)*8))&0xff);
+
+   return OO_OK;
+
+}
+
+int ooFreeQ931Message(Q931Message *q931Msg)
+{
+   if(!q931Msg)
+   {
+      memReset(&gH323ep.msgctxt);
+   }
+   return OO_OK;
+}
+
+int ooEncodeUUIE(Q931Message *q931msg)
+{
+   ASN1OCTET msgbuf[1024];
+   ASN1OCTET * msgptr=NULL;
+   int  len;
+   ASN1BOOL aligned = TRUE;
+   Q931InformationElement* ie=NULL;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   /*   memset(msgbuf, 0, sizeof(msgbuf));*/
+   if(!q931msg)
+   {
+      OOTRACEERR1("ERROR: Invalid Q931 message in add user-user IE\n");
+      return OO_FAILED;
+   }
+        
+   if(!q931msg->userInfo)
+   {
+      OOTRACEERR1("ERROR: No User-User IE to encode\n");
+      return OO_FAILED;
+   }
+
+   setPERBuffer(pctxt, msgbuf, sizeof(msgbuf), aligned);
+   
+   if(asn1PE_H225H323_UserInformation (pctxt, 
+                                           q931msg->userInfo)==ASN_OK)
+   {
+      OOTRACEDBGC1("UserInfo encoding - successful\n");
+   }
+   else{
+      OOTRACEERR1("ERROR: UserInfo encoding failed\n");
+      return OO_FAILED;
+   }
+   msgptr = encodeGetMsgPtr(pctxt, &len);
+
+   /* Allocate memory to hold complete UserUser Information */
+   ie = (Q931InformationElement*)memAlloc (pctxt,
+                                     sizeof(*ie) - sizeof(ie->data) + len);
+   if(ie == NULL)
+   {
+      OOTRACEERR1("Error: Memory -  ooEncodeUUIE - ie\n");
+      return OO_FAILED;
+   }
+   ie->discriminator = Q931UserUserIE;
+   ie->length = len;
+   memcpy(ie->data, msgptr, len);
+   /* Add the user to user IE NOTE: ALL IEs SHOULD BE IN ASCENDING ORDER OF 
+      THEIR DISCRIMINATOR AS PER SPEC. 
+   */
+   dListInit (&(q931msg->ies));
+   if((dListAppend (pctxt, 
+                      &(q931msg->ies), ie)) == NULL)
+   {
+      OOTRACEERR1("Error: Failed to add UUIE in outgoing message\n");
+      return OO_FAILED;
+   }
+
+   return OO_OK;
+}
+
+int ooDecodeUUIE(Q931Message *q931Msg)
+{
+   DListNode* curNode;
+   unsigned int i;
+   ASN1BOOL aligned=TRUE;
+   int stat;
+   Q931InformationElement *ie;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   if(q931Msg ==NULL)
+   {
+      OOTRACEERR1("Error: ooDecodeUUIE failed - NULL q931 message\n");
+      return OO_FAILED;
+   }
+        
+   /* Search for UserUser IE */
+   for(i = 0, curNode = q931Msg->ies.head; i < q931Msg->ies.count; 
+                                             i++, curNode = curNode->next) 
+   {
+      ie = (Q931InformationElement*) curNode->data;
+      if(ie->discriminator == Q931UserUserIE)
+         break;
+   }
+   if(i == q931Msg->ies.count)
+   {
+      OOTRACEERR1("No UserUser IE found in ooDecodeUUIE\n");
+      return OO_FAILED;
+   }
+        
+   /* Decode user-user ie */
+   q931Msg->userInfo = (H225H323_UserInformation *) memAlloc(pctxt,
+                                             sizeof(H225H323_UserInformation));
+   if(!q931Msg->userInfo)
+   {
+      OOTRACEERR1("ERROR:Memory - ooDecodeUUIE - userInfo\n");
+      return OO_FAILED;
+   }
+   memset(q931Msg->userInfo, 0, sizeof(H225H323_UserInformation));
+
+   setPERBuffer (pctxt, ie->data, ie->length, aligned);
+
+   stat = asn1PD_H225H323_UserInformation (pctxt, q931Msg->userInfo);
+   if(stat != ASN_OK)
+   {
+      OOTRACEERR1("Error: UserUser IE decode failed\n");
+      return OO_FAILED;
+   }
+   OOTRACEDBGC1("UUIE decode successful\n");
+   return OO_OK;
+}
+
+#ifndef _COMPACT
+static void ooQ931PrintMessage 
+   (OOH323CallData* call, ASN1OCTET *msgbuf, ASN1UINT msglen)
+{
+
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   Q931Message q931Msg;
+   int ret;
+
+   initializePrintHandler(&printHandler, "Q931 Message");
+
+   /* Set event handler */
+   setEventHandler (pctxt, &printHandler);
+
+   setPERBuffer (pctxt, msgbuf, msglen, TRUE);
+
+   ret = ooQ931Decode (call, &q931Msg, msglen, msgbuf);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed decoding Q931 message. (%s, %s)\n", 
+                 call->callType, call->callToken);
+   }
+   finishPrint();
+   removeEventHandler(pctxt);
+
+}
+#endif
+
+
+
+int ooEncodeH225Message(OOH323CallData *call, Q931Message *pq931Msg, 
+                        char *msgbuf, int size)
+{
+   int len=0, i=0, j=0, ieLen=0;
+   int stat=0;
+   DListNode* curNode=NULL;
+
+   if(!msgbuf || size<200)
+   {
+      OOTRACEERR3("Error: Invalid message buffer/size for ooEncodeH245Message."
+                  " (%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   if(pq931Msg->messageType == Q931SetupMsg){
+      msgbuf[i++] = OOSetup;
+   }
+   else if(pq931Msg->messageType == Q931ConnectMsg){
+      msgbuf[i++] = OOConnect;
+   }
+   else if(pq931Msg->messageType == Q931CallProceedingMsg){
+      msgbuf[i++] = OOCallProceeding;
+   }
+   else if(pq931Msg->messageType == Q931AlertingMsg){
+      msgbuf[i++] = OOAlert;
+   }
+   else if(pq931Msg->messageType == Q931ReleaseCompleteMsg){
+      msgbuf[i++] = OOReleaseComplete;
+   }
+   else if(pq931Msg->messageType == Q931InformationMsg){
+      msgbuf[i++] = OOInformationMessage;
+   }
+   else if(pq931Msg->messageType == Q931FacilityMsg){
+      msgbuf[i++] = OOFacility;
+      msgbuf[i++] = pq931Msg->tunneledMsgType;
+      msgbuf[i++] = pq931Msg->logicalChannelNo>>8;
+      msgbuf[i++] = pq931Msg->logicalChannelNo;
+   }
+   else{
+      OOTRACEERR3("Error:Unknow Q931 message type. (%s, %s)\n", call->callType,
+                   call->callToken);
+      return OO_FAILED;
+   }
+
+   stat = ooEncodeUUIE(pq931Msg);
+   if(stat != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to encode uuie. (%s, %s)\n", call->callType, 
+                   call->callToken);
+      return OO_FAILED;
+   }
+   
+   msgbuf[i++] = 3; /* TPKT version */
+   msgbuf[i++] = 0; /* TPKT resevred */
+   /* 1st octet of length, will be populated once len is determined */
+   msgbuf[i++] = 0; 
+   /* 2nd octet of length, will be populated once len is determined */
+   msgbuf[i++] = 0; 
+   /* Q931 protocol discriminator */
+   msgbuf[i++] = pq931Msg->protocolDiscriminator;
+   msgbuf[i++] = 2; /* length of call ref is two octets */
+   msgbuf[i] = (pq931Msg->callReference >> 8); /* populate 1st octet */
+   if(!strcmp(call->callType, "incoming"))
+      msgbuf[i++] |= 0x80;   /* fromDestination*/
+   else
+      i++;   /* fromOriginator*/
+
+  
+   msgbuf[i++] = pq931Msg->callReference; /* populate 2nd octet */
+   msgbuf[i++] = pq931Msg->messageType; /* type of q931 message */
+
+   /* Note: the order in which ies are added is important. It is in the
+      ascending order of ie codes. 
+   */
+   /* Add bearer IE */
+   if(pq931Msg->bearerCapabilityIE)
+   {   
+      msgbuf[i++] = Q931BearerCapabilityIE; /* ie discriminator */
+      msgbuf[i++] = pq931Msg->bearerCapabilityIE->length;
+      memcpy(msgbuf+i, pq931Msg->bearerCapabilityIE->data, 
+                       pq931Msg->bearerCapabilityIE->length);
+      i += pq931Msg->bearerCapabilityIE->length;
+   }   
+
+   /* Add cause IE */
+   if(pq931Msg->causeIE)
+   {
+      msgbuf[i++] = Q931CauseIE;
+      msgbuf[i++] = pq931Msg->causeIE->length;
+      memcpy(msgbuf+i, pq931Msg->causeIE->data, pq931Msg->causeIE->length);
+      i += pq931Msg->causeIE->length;
+   } 
+      
+   /*Add progress indicator IE 
+   if(pq931Msg->messageType == Q931AlertingMsg || pq931Msg->messageType == Q931CallProceedingMsg)
+   {
+      msgbuf[i++] = Q931ProgressIndicatorIE;
+      msgbuf[i++] = 2; //Length is 2 octet
+      msgbuf[i++] = 0x80; //PI=8
+      msgbuf[i++] = 0x88;
+  }*/
+
+   /*Add display ie. */
+   if(!ooUtilsIsStrEmpty(call->ourCallerId))
+   {
+      msgbuf[i++] = Q931DisplayIE;
+      ieLen = strlen(call->ourCallerId)+1;
+      msgbuf[i++] = ieLen;
+      memcpy(msgbuf+i, call->ourCallerId, ieLen-1);
+      i += ieLen-1;
+      msgbuf[i++] = '\0';
+   }
+
+   /* Add calling Party ie */
+   if(pq931Msg->callingPartyNumberIE)
+   {
+      msgbuf[i++] = Q931CallingPartyNumberIE;
+      msgbuf[i++] = pq931Msg->callingPartyNumberIE->length;
+      memcpy(msgbuf+i, pq931Msg->callingPartyNumberIE->data,
+                       pq931Msg->callingPartyNumberIE->length);
+      i += pq931Msg->callingPartyNumberIE->length;
+   }
+
+    /* Add called Party ie */
+   if(pq931Msg->calledPartyNumberIE)
+   {
+      msgbuf[i++] = Q931CalledPartyNumberIE;
+      msgbuf[i++] = pq931Msg->calledPartyNumberIE->length;
+      memcpy(msgbuf+i, pq931Msg->calledPartyNumberIE->data,
+                       pq931Msg->calledPartyNumberIE->length);
+      i += pq931Msg->calledPartyNumberIE->length;
+   }
+   
+   /* Add keypad ie */
+   if(pq931Msg->keypadIE)
+   {
+      msgbuf[i++] = Q931KeypadIE;
+      msgbuf[i++] = pq931Msg->keypadIE->length;
+      memcpy(msgbuf+i, pq931Msg->keypadIE->data, pq931Msg->keypadIE->length);
+      i += pq931Msg->keypadIE->length;
+   }
+
+   /* Note: Have to fix this, though it works. Need to get rid of ie list. 
+      Right now we only put UUIE in ie list. Can be easily removed.
+   */
+
+   for(j = 0, curNode = pq931Msg->ies.head; j < (int)pq931Msg->ies.count; j++) 
+   {
+      Q931InformationElement *ie = (Q931InformationElement*) curNode->data;
+          
+      ieLen = ie->length;
+
+      /* Add the ie discriminator in message buffer */
+      msgbuf[i++] = ie->discriminator; 
+          
+      /* For user-user IE, we have to add protocol discriminator */
+      if (ie->discriminator == Q931UserUserIE)
+      {
+         ieLen++; /* length includes protocol discriminator octet. */
+         msgbuf[i++] = (ieLen>>8); /* 1st octet for length */
+         msgbuf[i++] = ieLen;      /* 2nd octet for length */
+         ieLen--;
+         msgbuf[i++] = 5; /* protocol discriminator */
+         memcpy((msgbuf + i), ie->data, ieLen);
+
+         i += ieLen;
+         
+      }
+      else
+      {
+         OOTRACEWARN1("Warning: Only UUIE is supported currently\n");
+         return OO_FAILED;
+      }
+   }
+   //   len = i+1-4; /* complete message length */
+   
+
+   /* Tpkt length octets populated with total length of the message */
+   if(msgbuf[0] != OOFacility)
+   {
+      len = i-1;
+      msgbuf[3] = (len >> 8); 
+      msgbuf[4] = len;        /* including tpkt header */
+   }
+   else{
+      len = i-4;
+      msgbuf[6] = (len >> 8);
+      msgbuf[7] = len;
+   }
+  
+#ifndef _COMPACT
+   if(msgbuf[0] != OOFacility)
+      ooQ931PrintMessage (call, msgbuf+5, len-4);
+   else
+      ooQ931PrintMessage (call, msgbuf+8, len-4);
+#endif
+   return OO_OK;
+}
+
+int ooSetFastStartResponse(OOH323CallData *pCall, Q931Message *pQ931msg, 
+   ASN1UINT *fsCount, ASN1DynOctStr **fsElem)
+{
+   OOCTXT *pctxt = &gH323ep.msgctxt;   
+   int ret = 0, i=0, j=0, remoteMediaPort=0, remoteMediaControlPort = 0, dir=0;
+   char remoteMediaIP[20], remoteMediaControlIP[20];
+   DListNode *pNode = NULL;
+   H245OpenLogicalChannel *olc = NULL, printOlc;
+   ooH323EpCapability *epCap = NULL;
+   ASN1DynOctStr *pFS=NULL;
+   H245H2250LogicalChannelParameters *h2250lcp = NULL;  
+   ooLogicalChannel* pChannel;
+
+
+   if(pCall->pFastStartRes) {
+      ASN1UINT k = 0;
+      ASN1OCTET* pData;
+
+      /* copy the stored fast start response to structure */
+      *fsCount = pCall->pFastStartRes->n;
+      *fsElem = (ASN1DynOctStr*)
+         memAlloc(pctxt, pCall->pFastStartRes->n * sizeof(ASN1DynOctStr));
+
+      for(k = 0; k < pCall->pFastStartRes->n; k ++) {
+         (*fsElem)[k].numocts = pCall->pFastStartRes->elem[k].numocts;
+         pData = (ASN1OCTET*) memAlloc(
+            pctxt, (*fsElem)[k].numocts * sizeof(ASN1OCTET));
+         memcpy(pData, 
+            pCall->pFastStartRes->elem[k].data, 
+            pCall->pFastStartRes->elem[k].numocts);
+         (*fsElem)[k].data = pData;
+      }
+
+      /* free the stored fast start response */
+      if(pQ931msg->messageType == Q931ConnectMsg) {
+         for(k = 0; k < pCall->pFastStartRes->n; k ++) {
+            memFreePtr(pCall->pctxt, pCall->pFastStartRes->elem[k].data);
+         }
+         memFreePtr(pCall->pctxt, pCall->pFastStartRes->elem);
+         memFreePtr(pCall->pctxt, pCall->pFastStartRes);
+         pCall->pFastStartRes = NULL;
+      }
+
+      return ASN_OK;
+   }
+   
+      
+   /* If fast start supported and remote endpoint has sent faststart element */
+   if(OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART) && 
+      pCall->remoteFastStartOLCs.count>0)
+   {
+      pFS = (ASN1DynOctStr*)memAlloc(pctxt, 
+                        pCall->remoteFastStartOLCs.count*sizeof(ASN1DynOctStr));
+      if(!pFS)
+      {
+         OOTRACEERR3("Error:Memory - ooSetFastStartResponse - pFS (%s, %s)\n", 
+                      pCall->callType, pCall->callToken);    
+         return OO_FAILED;
+      }
+      memset(pFS, 0, pCall->remoteFastStartOLCs.count*sizeof(ASN1DynOctStr));
+
+      /* Go though all the proposed channels */
+      for(i=0, j=0; i<(int)pCall->remoteFastStartOLCs.count; i++)
+      {
+
+         pNode = dListFindByIndex(&pCall->remoteFastStartOLCs, i);
+         olc = (H245OpenLogicalChannel*)pNode->data;
+
+         /* Don't support both direction channel */
+         if(olc->forwardLogicalChannelParameters.dataType.t != 
+                                                   T_H245DataType_nullData &&
+            olc->m.reverseLogicalChannelParametersPresent)
+         {
+            OOTRACEINFO3("Ignoring bidirectional OLC as it is not supported."
+                         "(%s, %s)\n", pCall->callType, pCall->callToken);
+            continue;
+         }
+
+         /* Check forward logic channel */
+         if(olc->forwardLogicalChannelParameters.dataType.t != 
+                                                   T_H245DataType_nullData)
+         {
+            /* Forward Channel - remote transmits - local receives */
+            OOTRACEDBGC4("Processing received forward olc %d (%s, %s)\n", 
+                          olc->forwardLogicalChannelNumber, pCall->callType, 
+                          pCall->callToken);
+            dir = OORX;
+            epCap = ooIsDataTypeSupported(pCall, 
+                                &olc->forwardLogicalChannelParameters.dataType,
+                                OORX);
+            
+            if(!epCap) { continue; } /* Not Supported Channel */
+
+            OOTRACEINFO1("Receive Channel data type supported\n");
+            if(olc->forwardLogicalChannelParameters.multiplexParameters.t !=
+               T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
+            {
+               OOTRACEERR4("ERROR:Unknown multiplex parameter type for "
+                           "channel %d (%s, %s)\n", 
+                           olc->forwardLogicalChannelNumber, 
+                           pCall->callType, pCall->callToken);
+               memFreePtr(pCall->pctxt, epCap);
+               epCap = NULL;
+               continue;
+            }
+            h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;
+
+            /* Check session is Not already established */
+            if(ooIsSessionEstablished(pCall, olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, "receive"))
+            {
+
+               OOTRACEINFO4("Receive channel with sessionID %d already "
+                            "established.(%s, %s)\n", olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, 
+                            pCall->callType, pCall->callToken);
+               memFreePtr(pCall->pctxt, epCap);
+               epCap = NULL;
+               continue;
+            }
+
+            /* Extract mediaControlChannel info, if supplied */
+            if(h2250lcp->m.mediaControlChannelPresent)
+            {
+               if(OO_OK != ooGetIpPortFromH245TransportAddress(pCall, 
+                                &h2250lcp->mediaControlChannel, 
+                                remoteMediaControlIP, &remoteMediaControlPort))
+               {
+                  OOTRACEERR3("Error: Invalid media control channel address "
+                              "(%s, %s)\n", pCall->callType, pCall->callToken);
+                  memFreePtr(pCall->pctxt, epCap);
+                  epCap = NULL;
+                  continue;
+               }
+            }
+         }
+         /* Check reverse logical channel */
+         else if(olc->m.reverseLogicalChannelParametersPresent)
+         {
+            /* Reverse channel - remote receives - local transmits */
+            OOTRACEDBGC4("Processing received reverse olc %d (%s, %s)\n", 
+                          olc->forwardLogicalChannelNumber, pCall->callType, 
+                          pCall->callToken);
+            dir = OOTX;
+            epCap = ooIsDataTypeSupported(pCall, 
+                                &olc->reverseLogicalChannelParameters.dataType,
+                                OOTX);
+
+            if(!epCap) { continue; } /* Capability not supported */
+
+            OOTRACEINFO1("Transmit Channel data type supported\n");
+
+            if(olc->reverseLogicalChannelParameters.multiplexParameters.t != 
+               T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
+            {
+               OOTRACEERR4("ERROR:Unknown multiplex parameter type for "
+                           "channel %d (%s, %s)\n", 
+                           olc->forwardLogicalChannelNumber, 
+                           pCall->callType, pCall->callToken);
+               memFreePtr(pCall->pctxt, epCap);
+               epCap = NULL;
+               continue;
+            }
+
+            /* Check session is not established */
+            if(ooIsSessionEstablished(pCall, olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, "transmit"))
+            {
+
+               OOTRACEINFO4("Transmit session with sessionID %d already "
+                            "established.(%s, %s)\n", olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, pCall->callType, pCall->callToken);
+
+               memFreePtr(pCall->pctxt, epCap);
+               epCap = NULL;
+               continue;
+            }
+            
+            /* Extract the remote media endpoint address */
+            h2250lcp = olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;
+            if(!h2250lcp)
+            {
+               OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
+                           "reverse Logical Channel Parameters found. "
+                           "(%s, %s)\n", pCall->callType, pCall->callToken);
+               memFreePtr(pCall->pctxt, epCap);
+               epCap = NULL;
+               return OO_FAILED;
+            }
+            
+            /* Reverse Channel info will be always present, crash proof */
+            if(!h2250lcp->m.mediaChannelPresent)
+            {
+               OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
+                           "reverse media channel information found. "
+                           "(%s, %s)\n", pCall->callType, pCall->callToken);
+               memFreePtr(pCall->pctxt, epCap);
+               epCap = NULL;
+               return OO_FAILED;
+            }
+
+            /* Get IP, PORT of reverse channel */
+            if(OO_OK != ooGetIpPortFromH245TransportAddress(pCall, 
+                                &h2250lcp->mediaChannel, 
+                                remoteMediaIP, &remoteMediaPort))
+            {
+               OOTRACEERR3("Error: Invalid media  channel address "
+                           "(%s, %s)\n", pCall->callType, pCall->callToken);
+               memFreePtr(pCall->pctxt, epCap);
+               epCap = NULL;
+               continue;
+            }
+
+            /* Extract mediaControlChannel info, if supplied */
+            if(h2250lcp->m.mediaControlChannelPresent)
+            {
+               if(OO_OK != ooGetIpPortFromH245TransportAddress(pCall, 
+                                &h2250lcp->mediaControlChannel, 
+                                remoteMediaControlIP, &remoteMediaControlPort))
+               {
+                  OOTRACEERR3("Error: Invalid media control channel address "
+                              "(%s, %s)\n", pCall->callType, pCall->callToken);
+                  memFreePtr(pCall->pctxt, epCap);
+                  epCap = NULL;
+                  continue;
+               }
+            }
+         }
+
+         if(dir & OOTX)
+         {  
+            /* According to the spec if we are accepting olc for transmission
+               from called endpoint to calling endpoint, called endpoint should
+               insert a unqiue forwardLogicalChannelNumber into olc
+            */
+            olc->forwardLogicalChannelNumber =  pCall->logicalChanNoCur++;
+            if(pCall->logicalChanNoCur > pCall->logicalChanNoMax)
+               pCall->logicalChanNoCur = pCall->logicalChanNoBase;
+         }
+
+         
+         ooPrepareFastStartResponseOLC(pCall, olc, epCap, pctxt, dir);
+         
+         pChannel = ooFindLogicalChannelByLogicalChannelNo
+                      (pCall, olc->forwardLogicalChannelNumber);
+   
+         /* start receive and tramsmit channel listening */
+         if(dir & OORX)
+         {
+            strcpy(pChannel->remoteIP, remoteMediaControlIP);
+            pChannel->remoteMediaControlPort = remoteMediaControlPort;
+            if(epCap->startReceiveChannel)
+            {   
+               epCap->startReceiveChannel(pCall, pChannel);      
+               OOTRACEINFO4("Receive channel of type %s started (%s, %s)\n", 
+                        (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video",
+                        pCall->callType, pCall->callToken);
+            }
+            else{
+               OOTRACEERR4("ERROR:No callback registered to start receive %s"
+                          " channel (%s, %s)\n", 
+                        (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", 
+                           pCall->callType, pCall->callToken);
+               return OO_FAILED;
+            }
+         }
+         if(dir & OOTX)
+         {
+            pChannel->remoteMediaPort = remoteMediaPort;
+            strcpy(pChannel->remoteIP, remoteMediaIP);
+            pChannel->remoteMediaControlPort = remoteMediaControlPort;
+
+            if(epCap->startTransmitChannel)
+            {   
+               epCap->startTransmitChannel(pCall, pChannel);      
+               OOTRACEINFO3("Transmit channel of type audio started "
+                            "(%s, %s)\n", pCall->callType, pCall->callToken);
+               /*OO_SETFLAG (pCall->flags, OO_M_AUDIO);*/
+            }
+            else{
+               OOTRACEERR3("ERROR:No callback registered to start transmit"
+                           " audio channel (%s, %s)\n", pCall->callType, 
+                           pCall->callToken);
+               return OO_FAILED;
+            }
+         }
+
+         /* Encode fast start element */
+         setPERBuffer(pctxt, NULL, 0, 1);
+         if(asn1PE_H245OpenLogicalChannel(pctxt, olc) != ASN_OK)
+         {
+            OOTRACEERR3("ERROR:Encoding of olc failed for faststart "
+                        "(%s, %s)\n", pCall->callType, pCall->callToken);
+            ooFreeQ931Message(pQ931msg);
+            if(pCall->callState < OO_CALL_CLEAR)
+            {
+               pCall->callEndReason = OO_REASON_LOCAL_CLEARED;
+               pCall->callState = OO_CALL_CLEAR;
+            }
+            return OO_FAILED;
+         }
+         pFS[j].data = encodeGetMsgPtr(pctxt, &(pFS[j].numocts));
+
+
+         /* start print call */
+         setPERBuffer(pctxt,  (char*)pFS[j].data, pFS[j].numocts, 1);
+         initializePrintHandler(&printHandler, "FastStart Element");
+         setEventHandler (pctxt, &printHandler);
+         memset(&printOlc, 0, sizeof(printOlc));
+         ret = asn1PD_H245OpenLogicalChannel(pctxt, &(printOlc));
+         if(ret != ASN_OK)
+         {
+            OOTRACEERR3("Error: Failed decoding FastStart Element (%s, %s)\n", 
+                        pCall->callType, pCall->callToken);
+            ooFreeQ931Message(pQ931msg);
+            if(pCall->callState < OO_CALL_CLEAR)
+            {
+               pCall->callEndReason = OO_REASON_LOCAL_CLEARED;
+               pCall->callState = OO_CALL_CLEAR;
+            }
+            return OO_FAILED;
+         }
+         finishPrint();
+         removeEventHandler(pctxt); 
+         /* end print call */
+
+         olc = NULL;
+         j++;
+         epCap = NULL;
+      }
+      OOTRACEDBGA4("Added %d fast start elements to message "
+                   "(%s, %s)\n",  j, pCall->callType, pCall->callToken);
+      if(j != 0)
+      {
+         ASN1UINT k = 0;
+         ASN1OCTET* pData;
+         //*fsPresent = TRUE;
+         *fsCount = j;
+         *fsElem = pFS; 
+
+         /* save the fast start response for later use in ALERTING, CONNECT */
+         pCall->pFastStartRes = (FastStartResponse*)
+            memAlloc(pCall->pctxt, sizeof(FastStartResponse));
+         pCall->pFastStartRes->n = j;
+         pCall->pFastStartRes->elem = (ASN1DynOctStr*) memAlloc(pCall->pctxt, 
+            pCall->pFastStartRes->n * sizeof(ASN1DynOctStr));
+
+         for(k = 0; k < pCall->pFastStartRes->n; k ++) {
+            pCall->pFastStartRes->elem[k].numocts = (*fsElem)[k].numocts;
+            pData = (ASN1OCTET*) memAlloc(pCall->pctxt, 
+               pCall->pFastStartRes->elem[k].numocts * sizeof(ASN1OCTET));
+            memcpy(pData, (*fsElem)[k].data, (*fsElem)[k].numocts);
+            pCall->pFastStartRes->elem[k].data = pData;
+         }
+      }
+      else{
+         OOTRACEINFO3("None of the faststart elements received in setup can be"
+                      " supported, rejecting faststart.(%s, %s)\n", 
+                      pCall->callType, pCall->callToken);
+         //*fsPresent = FALSE;
+         OO_CLRFLAG(pCall->flags, OO_M_FASTSTART);
+         OOTRACEDBGC3("Faststart for pCall is disabled by local endpoint."
+                      "(%s, %s)\n", pCall->callType, pCall->callToken);
+      }
+   }
+   return ASN_OK;
+}
+
+
+/*
+
+*/
+
+int ooSendCallProceeding(OOH323CallData *call)
+{
+   int ret;    
+   H225VendorIdentifier *vendor;
+   H225CallProceeding_UUIE *callProceeding;
+   Q931Message *q931msg=NULL;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   OOTRACEDBGC3("Building CallProceeding (%s, %s)\n", call->callType, 
+                 call->callToken);
+   ret = ooCreateQ931Message(&q931msg, Q931CallProceedingMsg);
+   if(ret != OO_OK)
+   {      
+      OOTRACEERR1("Error: In allocating memory for - H225 Call "
+                           "Proceeding message\n");
+      return OO_FAILED;
+   }
+   
+   q931msg->callReference = call->callReference;
+
+   q931msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt,
+                             sizeof(H225H323_UserInformation));
+   if(!q931msg->userInfo)
+   {
+      OOTRACEERR1("ERROR:Memory - ooSendCallProceeding - userInfo\n");
+      return OO_FAILED;
+   }
+   memset (q931msg->userInfo, 0, sizeof(H225H323_UserInformation));
+   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; 
+   q931msg->userInfo->h323_uu_pdu.h245Tunneling = 
+                                   OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING); 
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+         T_H225H323_UU_PDU_h323_message_body_callProceeding;
+   
+   callProceeding = (H225CallProceeding_UUIE*)memAlloc(pctxt,
+                                             sizeof(H225CallProceeding_UUIE));
+   if(!callProceeding)
+   {
+      OOTRACEERR1("ERROR:Memory - ooSendCallProceeding - callProceeding\n");
+      return OO_FAILED;
+   }
+   memset(callProceeding, 0, sizeof(H225CallProceeding_UUIE));
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.u.callProceeding = callProceeding;
+   callProceeding->m.multipleCallsPresent = 1;
+   callProceeding->m.maintainConnectionPresent = 1;
+   callProceeding->multipleCalls = FALSE;
+   callProceeding->maintainConnection = FALSE;
+
+   callProceeding->m.callIdentifierPresent = 1;
+   callProceeding->callIdentifier.guid.numocts = 
+                                   call->callIdentifier.guid.numocts;
+   memcpy(callProceeding->callIdentifier.guid.data, 
+          call->callIdentifier.guid.data, 
+          call->callIdentifier.guid.numocts);
+   callProceeding->protocolIdentifier = gProtocolID;  
+
+   /* Pose as Terminal or Gateway */
+   if(gH323ep.isGateway)
+      callProceeding->destinationInfo.m.gatewayPresent = TRUE;
+   else
+      callProceeding->destinationInfo.m.terminalPresent = TRUE;
+
+   callProceeding->destinationInfo.m.vendorPresent = 1;
+   vendor = &callProceeding->destinationInfo.vendor;
+   if(gH323ep.productID)
+   {
+      vendor->m.productIdPresent = 1;
+      vendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), 
+                                    sizeof(vendor->productId.data));
+      strncpy(vendor->productId.data, gH323ep.productID, 
+              vendor->productId.numocts);
+   }
+   if(gH323ep.versionID)
+   {
+      vendor->m.versionIdPresent = 1;
+      vendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), 
+                                     sizeof(vendor->versionId.data));
+      strncpy(vendor->versionId.data, gH323ep.versionID, 
+              vendor->versionId.numocts); 
+   }
+
+   vendor->vendor.t35CountryCode = gH323ep.t35CountryCode;
+   vendor->vendor.t35Extension = gH323ep.t35Extension;
+   vendor->vendor.manufacturerCode = gH323ep.manufacturerCode;
+      
+   OOTRACEDBGA3("Built Call Proceeding(%s, %s)\n", call->callType, 
+                 call->callToken);   
+   ret = ooSendH225Msg(call, q931msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue CallProceeding message to outbound queue.(%s, %s)\n", call->callType, call->callToken);
+   }
+
+   memReset(&gH323ep.msgctxt);
+
+   return ret;
+}
+
+int ooSendAlerting(OOH323CallData *call)
+{
+   int ret;    
+   H225Alerting_UUIE *alerting;
+   H225VendorIdentifier *vendor;
+   Q931Message *q931msg=NULL;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   ret = ooCreateQ931Message(&q931msg, Q931AlertingMsg);
+   if(ret != OO_OK)
+   {      
+      OOTRACEERR1("Error: In allocating memory for - H225 "
+                  "Alerting message\n");
+      return OO_FAILED;
+   }
+
+   q931msg->callReference = call->callReference;
+
+   q931msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt,
+                             sizeof(H225H323_UserInformation));
+   if(!q931msg->userInfo)
+   {
+      OOTRACEERR1("ERROR:Memory -  ooSendAlerting - userInfo\n");
+      return OO_FAILED;
+   }
+   memset (q931msg->userInfo, 0, sizeof(H225H323_UserInformation));
+   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; 
+   q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG(gH323ep.flags, 
+                                                              OO_M_TUNNELING); 
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+         T_H225H323_UU_PDU_h323_message_body_alerting;
+   
+   alerting = (H225Alerting_UUIE*)memAlloc(pctxt, 
+                                             sizeof(H225Alerting_UUIE));
+   if(!alerting)
+   {
+      OOTRACEERR1("ERROR:Memory -  ooSendAlerting - alerting\n");
+      return OO_FAILED;
+   }
+   memset(alerting, 0, sizeof(H225Alerting_UUIE));
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.u.alerting = alerting;
+   alerting->m.multipleCallsPresent = 1;
+   alerting->m.maintainConnectionPresent = 1;
+   alerting->multipleCalls = FALSE;
+   alerting->maintainConnection = FALSE;
+
+   /*Populate aliases */
+   alerting->m.alertingAddressPresent = TRUE;
+   if(call->ourAliases)
+      ret = ooPopulateAliasList(pctxt, call->ourAliases, 
+                                       &alerting->alertingAddress);
+   else
+      ret = ooPopulateAliasList(pctxt, gH323ep.aliases,
+                                       &alerting->alertingAddress);
+   if(OO_OK != ret)
+   {
+      OOTRACEERR1("Error:Failed to populate alias list in Alert message\n");
+      memReset(pctxt);
+      return OO_FAILED;
+   }
+   alerting->m.presentationIndicatorPresent = TRUE;
+   alerting->presentationIndicator.t = 
+                             T_H225PresentationIndicator_presentationAllowed;
+   alerting->m.screeningIndicatorPresent = TRUE;
+   alerting->screeningIndicator = userProvidedNotScreened;
+
+
+
+   alerting->m.callIdentifierPresent = 1;
+   alerting->callIdentifier.guid.numocts = 
+                                   call->callIdentifier.guid.numocts;
+   memcpy(alerting->callIdentifier.guid.data, 
+          call->callIdentifier.guid.data, 
+          call->callIdentifier.guid.numocts);
+   alerting->protocolIdentifier = gProtocolID;  
+
+   /* Pose as Terminal or Gateway */
+   if(gH323ep.isGateway)
+      alerting->destinationInfo.m.gatewayPresent = TRUE;
+   else
+      alerting->destinationInfo.m.terminalPresent = TRUE;
+
+   alerting->destinationInfo.m.vendorPresent = 1;
+   vendor = &alerting->destinationInfo.vendor;
+   if(gH323ep.productID)
+   {
+      vendor->m.productIdPresent = 1;
+      vendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), 
+                                        sizeof(vendor->productId.data));
+      strncpy(vendor->productId.data, gH323ep.productID, 
+                                        vendor->productId.numocts);
+   }
+   if(gH323ep.versionID)
+   {
+      vendor->m.versionIdPresent = 1;
+      vendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), 
+                                        sizeof(vendor->versionId.data));
+      strncpy(vendor->versionId.data, gH323ep.versionID, 
+              vendor->versionId.numocts); 
+   }
+      
+   vendor->vendor.t35CountryCode = gH323ep.t35CountryCode;
+   vendor->vendor.t35Extension = gH323ep.t35Extension;
+   vendor->vendor.manufacturerCode = gH323ep.manufacturerCode;
+   
+   ret = ooSetFastStartResponse(call, q931msg, 
+      &alerting->fastStart.n, &alerting->fastStart.elem);
+   if(ret != ASN_OK) { return ret; }
+   if(alerting->fastStart.n > 0) {
+      alerting->m.fastStartPresent = TRUE;
+   }
+   else {
+      alerting->m.fastStartPresent = FALSE;
+   }
+
+   OOTRACEDBGA3("Built Alerting (%s, %s)\n", call->callType, call->callToken);
+   
+   ret = ooSendH225Msg(call, q931msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error: Failed to enqueue Alerting message to outbound queue. (%s, %s)\n", call->callType, call->callToken);
+   }
+
+   memReset(&gH323ep.msgctxt);
+
+   return ret;
+}
+
+
+int ooSendFacility(OOH323CallData *call)
+{
+   int ret=0;
+   Q931Message *pQ931Msg = NULL;
+   H225Facility_UUIE *facility=NULL;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   OOTRACEDBGA3("Building Facility message (%s, %s)\n", call->callType,
+                 call->callToken);
+   ret = ooCreateQ931Message(&pQ931Msg, Q931FacilityMsg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3
+         ("ERROR: In allocating memory for facility message (%s, %s)\n",
+          call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   pQ931Msg->callReference = call->callReference;
+
+   pQ931Msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt,
+                             sizeof(H225H323_UserInformation));
+   if(!pQ931Msg->userInfo)
+   {
+      OOTRACEERR3("ERROR:Memory - ooSendFacility - userInfo(%s, %s)\n", 
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   memset (pQ931Msg->userInfo, 0, sizeof(H225H323_UserInformation));
+   pQ931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; 
+
+   pQ931Msg->userInfo->h323_uu_pdu.h245Tunneling = 
+      OO_TESTFLAG (call->flags, OO_M_TUNNELING); 
+
+   pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+      T_H225H323_UU_PDU_h323_message_body_facility;
+   
+   facility = (H225Facility_UUIE*) 
+      memAllocZ (pctxt, sizeof(H225Facility_UUIE));
+
+   if(!facility)
+   {
+      OOTRACEERR3("ERROR:Memory - ooSendFacility - facility (%s, %s)"
+                  "\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.u.facility = facility;
+
+   /* Populate Facility UUIE */
+   facility->protocolIdentifier = gProtocolID;  
+   facility->m.callIdentifierPresent = 1;
+   facility->callIdentifier.guid.numocts = 
+                                   call->callIdentifier.guid.numocts;
+   memcpy(facility->callIdentifier.guid.data, 
+          call->callIdentifier.guid.data, 
+          call->callIdentifier.guid.numocts);
+   facility->reason.t = T_H225FacilityReason_transportedInformation;
+   OOTRACEDBGA3("Built Facility message to send (%s, %s)\n", call->callType,
+                 call->callToken);
+
+   ret = ooSendH225Msg(call, pQ931Msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3
+         ("Error:Failed to enqueue Facility message to outbound "
+         "queue.(%s, %s)\n", call->callType, call->callToken);
+   }
+   memReset (&gH323ep.msgctxt);
+   return ret;
+}
+
+int ooSendReleaseComplete(OOH323CallData *call)
+{
+   int ret;   
+   Q931Message *q931msg=NULL;
+   H225ReleaseComplete_UUIE *releaseComplete;
+   enum Q931CauseValues cause = Q931ErrorInCauseIE;
+   unsigned h225ReasonCode = T_H225ReleaseCompleteReason_undefinedReason;
+
+   OOCTXT *pctxt = &gH323ep.msgctxt;   
+   OOTRACEDBGA3("Building Release Complete message to send(%s, %s)\n",
+                call->callType, call->callToken);
+   ret = ooCreateQ931Message(&q931msg, Q931ReleaseCompleteMsg);
+   if(ret != OO_OK)
+   {      
+      OOTRACEERR3("Error: In ooCreateQ931Message - H225 Release Complete "
+                  "message(%s, %s)\n", call->callType, call->callToken);
+      if(call->callState < OO_CALL_CLEAR)
+      {
+         call->callEndReason = OO_REASON_LOCAL_CLEARED;
+         call->callState = OO_CALL_CLEAR;
+      }
+      return OO_FAILED;
+   }
+
+   q931msg->callReference = call->callReference;
+
+   q931msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt,
+                             sizeof(H225H323_UserInformation));
+   if(!q931msg->userInfo)
+   {
+      OOTRACEERR1("ERROR:Memory - ooSendReleaseComplete - userInfo\n");
+      return OO_FAILED;
+   }
+   memset (q931msg->userInfo, 0, sizeof(H225H323_UserInformation));
+
+   releaseComplete = (H225ReleaseComplete_UUIE*)memAlloc(pctxt,
+                                             sizeof(H225ReleaseComplete_UUIE));
+   if(!releaseComplete)
+   {
+      OOTRACEERR3("Error:Memory - ooSendReleaseComplete - releaseComplete"
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   memset(releaseComplete, 0, sizeof(H225ReleaseComplete_UUIE));
+   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; 
+   q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG(gH323ep.flags, 
+                                                              OO_M_TUNNELING); 
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+         T_H225H323_UU_PDU_h323_message_body_releaseComplete;
+   
+   /* Get cause value and h225 reason code corresponding to OOCallClearReason*/
+   ooQ931GetCauseAndReasonCodeFromCallClearReason(call->callEndReason, 
+                                                     &cause, &h225ReasonCode);
+   /* Set Cause IE */
+   ooQ931SetCauseIE(q931msg, cause, 0, 0);
+   
+   /* Set H225 releaseComplete reasonCode */
+   releaseComplete->m.reasonPresent = TRUE;
+   releaseComplete->reason.t = h225ReasonCode;
+
+   /* Add user-user ie */
+   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=TRUE; 
+   q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG (call->flags, OO_M_TUNNELING);
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+           T_H225H323_UU_PDU_h323_message_body_releaseComplete;
+   
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.u.releaseComplete = 
+                                                             releaseComplete;
+   releaseComplete->m.callIdentifierPresent = 1;
+   releaseComplete->protocolIdentifier = gProtocolID;
+   releaseComplete->callIdentifier.guid.numocts = 
+           call->callIdentifier.guid.numocts;
+   memcpy(releaseComplete->callIdentifier.guid.data, 
+                                  call->callIdentifier.guid.data,
+                                  call->callIdentifier.guid.numocts);
+
+   OOTRACEDBGA3("Built Release Complete message (%s, %s)\n",
+                call->callType, call->callToken);
+   /* Send H225 message */   
+   ret = ooSendH225Msg(call, q931msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue ReleaseComplete message to outbound"
+                  " queue.(%s, %s)\n", call->callType, call->callToken);
+   }
+   memReset(&gH323ep.msgctxt);
+
+   return ret;
+}
+
+int ooSendConnect(OOH323CallData *call)
+{
+   ooAcceptCall(call);
+   return OO_OK;
+}
+
+/*TODO: Need to clean logical channel in case of failure after creating one */
+int ooAcceptCall(OOH323CallData *call)
+{
+   int ret = 0, i=0;
+   H225Connect_UUIE *connect;
+   H225TransportAddress_ipAddress *h245IpAddr;
+   H225VendorIdentifier *vendor;
+   Q931Message *q931msg=NULL;
+   OOCTXT *pctxt = &gH323ep.msgctxt;   
+
+   ret = ooCreateQ931Message(&q931msg, Q931ConnectMsg);
+   if(ret != OO_OK)
+   {      
+      OOTRACEERR1("Error: In allocating memory for - H225 "
+                  "Connect message\n");
+      return OO_FAILED;
+   }
+   q931msg->callReference = call->callReference;
+
+   /* Set bearer capability */
+   if(OO_OK != ooSetBearerCapabilityIE(q931msg, Q931CCITTStd, 
+                       Q931TransferUnrestrictedDigital, Q931TransferPacketMode,
+                       Q931TransferRatePacketMode, Q931UserInfoLayer1G722G725))
+     //                          Q931TransferSpeech, Q931TransferCircuitMode,
+     //                   Q931TransferRate64Kbps, Q931UserInfoLayer1G711ULaw))
+   {
+      OOTRACEERR3("Error: Failed to set bearer capability ie. (%s, %s)\n",
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   q931msg->userInfo = (H225H323_UserInformation*)
+      memAllocZ (pctxt,sizeof(H225H323_UserInformation));
+
+   if(!q931msg->userInfo)
+   {
+      OOTRACEERR1("ERROR:Memory - ooAcceptCall - userInfo\n");
+      return OO_FAILED;
+   }   
+
+   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=TRUE; 
+
+   q931msg->userInfo->h323_uu_pdu.h245Tunneling = 
+      OO_TESTFLAG (call->flags, OO_M_TUNNELING); 
+
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+      T_H225H323_UU_PDU_h323_message_body_connect;
+   
+   connect = (H225Connect_UUIE*)
+      memAllocZ (pctxt, sizeof(H225Connect_UUIE));
+
+   if(!connect)
+   {
+      OOTRACEERR1("ERROR:Memory - ooAcceptCall - connect\n");
+      return OO_FAILED;
+   }
+
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.u.connect = connect;
+   connect->m.fastStartPresent = 0;
+   connect->m.multipleCallsPresent = 1;
+   connect->m.maintainConnectionPresent = 1;
+   connect->multipleCalls = FALSE;
+   connect->maintainConnection = FALSE;
+   
+   
+   connect->conferenceID.numocts = 16;
+   for (i = 0; i < 16; i++)
+      connect->conferenceID.data[i] = i + 1;
+
+   connect->m.callIdentifierPresent = 1;
+   connect->callIdentifier.guid.numocts = 
+                                 call->callIdentifier.guid.numocts;
+   memcpy(connect->callIdentifier.guid.data, call->callIdentifier.guid.data, 
+                                         call->callIdentifier.guid.numocts);
+   
+   connect->conferenceID.numocts = call->confIdentifier.numocts;
+   memcpy(connect->conferenceID.data, call->confIdentifier.data,
+          call->confIdentifier.numocts);
+   /* Populate alias addresses */
+   connect->m.connectedAddressPresent = TRUE;
+   if(call->ourAliases)
+      ret = ooPopulateAliasList(pctxt, call->ourAliases, 
+                                      &connect->connectedAddress);
+   else
+      ret =  ooPopulateAliasList(pctxt, gH323ep.aliases, 
+                                        &connect->connectedAddress);
+   if(OO_OK != ret)
+   {
+      OOTRACEERR1("Error:Failed to populate alias list in Connect message\n");
+      memReset(pctxt);
+      return OO_FAILED;
+   }
+   connect->m.presentationIndicatorPresent = TRUE;
+   connect->presentationIndicator.t = 
+                             T_H225PresentationIndicator_presentationAllowed;
+   connect->m.screeningIndicatorPresent = TRUE;
+   connect->screeningIndicator = userProvidedNotScreened;
+
+   connect->protocolIdentifier = gProtocolID;  
+
+   /* Pose as Terminal or Gateway */
+   if(gH323ep.isGateway)
+      connect->destinationInfo.m.gatewayPresent = TRUE;
+   else
+      connect->destinationInfo.m.terminalPresent = TRUE;
+
+   
+   connect->destinationInfo.m.vendorPresent = 1;
+   vendor = &connect->destinationInfo.vendor;
+      
+   vendor->vendor.t35CountryCode = gH323ep.t35CountryCode;
+   vendor->vendor.t35Extension = gH323ep.t35Extension;
+   vendor->vendor.manufacturerCode = gH323ep.manufacturerCode;
+   if(gH323ep.productID)
+   {
+      vendor->m.productIdPresent = 1;
+      vendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), 
+                                            sizeof(vendor->productId.data));
+      strncpy(vendor->productId.data, gH323ep.productID, 
+                                                   vendor->productId.numocts);
+   }
+   if(gH323ep.versionID)
+   {
+      vendor->m.versionIdPresent = 1;
+      vendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), 
+                                           sizeof(vendor->versionId.data));
+      strncpy(vendor->versionId.data, gH323ep.versionID, 
+                                                   vendor->versionId.numocts); 
+   }
+
+   ret = ooSetFastStartResponse(call, q931msg, 
+      &connect->fastStart.n, &connect->fastStart.elem);
+   if(ret != ASN_OK) { return ret; }
+   if(connect->fastStart.n > 0) {
+      connect->m.fastStartPresent = TRUE;
+   }
+   else {
+      connect->m.fastStartPresent = FALSE;
+   }
+
+   /* Add h245 listener address. Do not add H245 listener address in case
+      of fast-start. */
+   if ((!OO_TESTFLAG(call->flags, OO_M_FASTSTART) || 
+        call->remoteFastStartOLCs.count == 0) &&
+       !OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+   {
+      ooCreateH245Listener(call); /* First create an H.245 listener */
+      connect->m.h245AddressPresent = TRUE;
+      connect->h245Address.t = T_H225TransportAddress_ipAddress;
+   
+      h245IpAddr = (H225TransportAddress_ipAddress*)
+         memAllocZ (pctxt, sizeof(H225TransportAddress_ipAddress));
+      if(!h245IpAddr)
+      {
+         OOTRACEERR3("Error:Memory - ooAcceptCall - h245IpAddr"
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      ooSocketConvertIpToNwAddr(call->localIP, h245IpAddr->ip.data);
+      h245IpAddr->ip.numocts=4;
+      h245IpAddr->port = *(call->h245listenport);
+      connect->h245Address.u.ipAddress = h245IpAddr;
+   }
+
+   OOTRACEDBGA3("Built H.225 Connect message (%s, %s)\n", call->callType,
+                 call->callToken);
+
+   /* H225 message callback */
+   if(gH323ep.h225Callbacks.onBuiltConnect)
+      gH323ep.h225Callbacks.onBuiltConnect(call, q931msg);
+
+   ret=ooSendH225Msg(call, q931msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue Connect message to outbound queue.(%s, %s)\n", call->callType, call->callToken);
+      memReset(&gH323ep.msgctxt);
+      return OO_FAILED;
+   }
+   memReset(&gH323ep.msgctxt);
+
+#if 0
+   if (OO_TESTFLAG (call->flags, OO_M_TUNNELING))
+   {
+      /* Start terminal capability exchange and master slave determination */
+      ret = ooSendTermCapMsg(call);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n",
+                      call->callType, call->callToken);
+         return ret;
+      }
+      ret = ooSendMasterSlaveDetermination(call);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR3("ERROR:Sending Master-slave determination message "
+                  "(%s, %s)\n", call->callType, call->callToken);
+         return ret;
+      }   
+   }
+#endif
+   return OO_OK;
+}
+
+int ooH323HandleCallFwdRequest(OOH323CallData *call)
+{
+   OOH323CallData *fwdedCall=NULL;
+   OOCTXT *pctxt;
+   ooAliases *pNewAlias=NULL, *alias=NULL;
+   int i=0, irand=0, ret = OO_OK;
+   /* Note: We keep same callToken, for new call which is going
+      to replace an existing call, thus treating it as a single call.*/
+
+   fwdedCall = ooCreateCall("outgoing", call->callToken);
+
+   pctxt = fwdedCall->pctxt;
+
+   /* Retrieve new destination info from original call */
+   if(!ooUtilsIsStrEmpty(call->pCallFwdData->ip))
+   {
+      strcpy(fwdedCall->remoteIP, call->pCallFwdData->ip);
+   }
+   fwdedCall->remotePort = call->pCallFwdData->port;
+   
+   if(call->pCallFwdData->aliases)
+   {
+      alias = call->pCallFwdData->aliases;
+      while(alias)
+      {
+         pNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases));
+         pNewAlias->value = (char*) memAlloc(pctxt, strlen(alias->value)+1);
+         if(!pNewAlias || !pNewAlias->value)
+         {
+            OOTRACEERR3("Error:Memory - ooH323HandleCallFwdRequest - "
+                        "pNewAlias/pNewAlias->value"
+                        "(%s, %s)\n", call->callType, call->callToken);
+            ooCleanCall(fwdedCall);
+            return OO_FAILED;
+         }
+         pNewAlias->type = alias->type;
+         strcpy(pNewAlias->value, alias->value);
+         pNewAlias->next = fwdedCall->remoteAliases;
+         fwdedCall->remoteAliases = pNewAlias;
+         alias = alias->next;
+         pNewAlias = NULL;
+      }
+   }
+
+   fwdedCall->callReference = ooGenerateCallReference();
+   ooGenerateCallIdentifier(&fwdedCall->callIdentifier);
+   fwdedCall->confIdentifier.numocts = 16;
+   irand = rand();
+   for (i = 0; i < 16; i++) {
+      fwdedCall->confIdentifier.data[i] = irand++;
+   }
+      
+
+   if(gH323ep.gkClient && !OO_TESTFLAG(fwdedCall->flags, OO_M_DISABLEGK))
+   {
+     /* No need to check registration status here as it is already checked for
+        MakeCall command */
+      ret = ooGkClientSendAdmissionRequest(gH323ep.gkClient, fwdedCall, FALSE);
+      fwdedCall->callState = OO_CALL_WAITING_ADMISSION;
+   }
+   else {
+      ret = ooH323CallAdmitted (fwdedCall);
+   }
+
+   return OO_OK;
+
+}
+
+int ooH323MakeCall(char *dest, char *callToken, ooCallOptions *opts)
+{
+   OOCTXT *pctxt;
+   OOH323CallData *call;
+   int ret=0, i=0, irand=0;
+   char tmp[30]="\0";
+   char *ip=NULL, *port = NULL;
+
+   if(!dest)
+   {
+      OOTRACEERR1("ERROR:Invalid destination for new call\n");
+      return OO_FAILED;
+   }
+   if(!callToken)
+   {
+      OOTRACEERR1("ERROR: Invalid callToken parameter to make call\n");
+      return OO_FAILED;
+   }
+
+   call = ooCreateCall("outgoing", callToken);
+   pctxt = call->pctxt;
+   if(opts)
+   {
+      if(opts->fastStart)
+         OO_SETFLAG(call->flags, OO_M_FASTSTART);
+      else
+         OO_CLRFLAG(call->flags, OO_M_FASTSTART);
+
+      if(opts->tunneling)
+         OO_SETFLAG(call->flags, OO_M_TUNNELING);
+      else
+         OO_CLRFLAG(call->flags, OO_M_TUNNELING);
+
+      if(opts->disableGk)
+         OO_SETFLAG(call->flags, OO_M_DISABLEGK);
+      else
+         OO_CLRFLAG(call->flags, OO_M_DISABLEGK);
+
+      call->callMode = opts->callMode;
+   }
+
+
+   ret = ooParseDestination(call, dest, tmp, 30, &call->remoteAliases);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR2("Error: Failed to parse the destination string %s for "
+                  "new call\n", dest);
+      ooCleanCall(call);
+      return OO_FAILED;
+   }
+   
+   /* Check whether we have ip address */
+   if(!ooUtilsIsStrEmpty(tmp)) {
+      ip = tmp;
+      port = strchr(tmp, ':');
+      *port = '\0';
+      port++;
+      strcpy(call->remoteIP, ip);
+      call->remotePort = atoi(port);
+   }
+
+   strcpy(callToken, call->callToken);
+   call->callReference = ooGenerateCallReference();
+   ooGenerateCallIdentifier(&call->callIdentifier);
+   call->confIdentifier.numocts = 16;
+   irand = rand();
+   for (i = 0; i < 16; i++) {
+      call->confIdentifier.data[i] = irand++;
+   }
+      
+
+   if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK))
+   {
+     /* No need to check registration status here as it is already checked for
+        MakeCall command */
+      ret = ooGkClientSendAdmissionRequest(gH323ep.gkClient, call, FALSE);
+      call->callState = OO_CALL_WAITING_ADMISSION;
+   }
+   else {
+      /* Send as H225 message to calling endpoint */
+      ret = ooH323CallAdmitted (call);
+   }
+
+   return OO_OK;
+}
+
+
+int ooH323CallAdmitted(OOH323CallData *call)
+{
+   int ret=0;
+      
+   if(!call)
+   {
+      /* Call not supplied. Must locate it in list */
+      OOTRACEERR1("ERROR: Invalid call parameter to ooH323CallAdmitted");
+      return OO_FAILED; 
+   }
+
+   if(!strcmp(call->callType, "outgoing")) {
+      ret = ooCreateH225Connection(call);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR3("ERROR:Failed to create H225 connection to %s:%d\n", 
+                      call->remoteIP, call->remotePort);
+         if(call->callState< OO_CALL_CLEAR)
+         {
+            call->callState = OO_CALL_CLEAR;
+            call->callEndReason = OO_REASON_UNKNOWN;
+         }
+         return OO_FAILED;
+      }
+      
+      ret = ooH323MakeCall_helper(call);
+   } 
+   else { 
+      /* incoming call */
+      if(gH323ep.h323Callbacks.onIncomingCall) {
+         /* Incoming call callback function */
+         gH323ep.h323Callbacks.onIncomingCall(call);
+      }
+
+      /* Check for manual ringback generation */
+      if(!OO_TESTFLAG(gH323ep.flags, OO_M_MANUALRINGBACK))
+      {
+         ooSendAlerting(call); /* Send alerting message */
+
+         if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER)) {
+            ooSendConnect(call); /* Send connect message - call accepted */
+         }
+      }
+   }
+   
+   return OO_OK;
+}
+
+int ooH323MakeCall_helper(OOH323CallData *call)
+{
+   int ret=0,i=0, k;
+   Q931Message *q931msg = NULL;
+   H225Setup_UUIE *setup;
+
+   ASN1DynOctStr *pFS=NULL;
+   H225TransportAddress_ipAddress *destCallSignalIpAddress;
+
+   H225TransportAddress_ipAddress *srcCallSignalIpAddress;
+   ooH323EpCapability *epCap=NULL;
+   OOCTXT *pctxt = NULL;
+   H245OpenLogicalChannel *olc, printOlc;
+   ASN1BOOL aligned = 1;
+   ooAliases *pAlias = NULL;
+
+   pctxt = &gH323ep.msgctxt;
+     
+   ret = ooCreateQ931Message(&q931msg, Q931SetupMsg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR1("ERROR:Failed to Create Q931 SETUP Message\n ");
+      return OO_FAILED;
+   }
+
+   q931msg->callReference = call->callReference;
+
+   /* Set bearer capability */
+   if(OO_OK != ooSetBearerCapabilityIE(q931msg, Q931CCITTStd, 
+                          Q931TransferUnrestrictedDigital, Q931TransferPacketMode,
+                          Q931TransferRatePacketMode, Q931UserInfoLayer1G722G725))
+//                        Q931TransferRate64Kbps, Q931UserInfoLayer1G711ULaw))
+   {
+      OOTRACEERR3("Error: Failed to set bearer capability ie.(%s, %s)\n",
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   /* Set calling party number  Q931 IE */
+   if(call->callingPartyNumber)
+     ooQ931SetCallingPartyNumberIE(q931msg,
+                            (const char*)call->callingPartyNumber, 1, 0, 0, 0);
+   
+
+   /* Set called party number Q931 IE */
+   if(call->calledPartyNumber)
+      ooQ931SetCalledPartyNumberIE(q931msg, 
+                            (const char*)call->calledPartyNumber, 1, 0);
+   else if(call->remoteAliases) {
+      pAlias = call->remoteAliases;
+      while(pAlias) {
+         if(pAlias->type == T_H225AliasAddress_dialedDigits)
+            break;
+         pAlias = pAlias->next;
+      }
+      if(pAlias)
+      {
+         call->calledPartyNumber = (char*)memAlloc(call->pctxt, 
+                                                   strlen(pAlias->value)+1);
+         if(!call->calledPartyNumber)
+         {
+            OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - "
+                        "calledPartyNumber(%s, %s)\n", call->callType, 
+                        call->callToken);
+            return OO_FAILED;
+         }
+         strcpy(call->calledPartyNumber, pAlias->value);
+         ooQ931SetCalledPartyNumberIE(q931msg, 
+                            (const char*)call->calledPartyNumber, 1, 0);
+      }
+
+   }
+
+   q931msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt,
+                             sizeof(H225H323_UserInformation));
+   if(!q931msg->userInfo)
+   {
+      OOTRACEERR1("ERROR:Memory - ooH323MakeCall_helper - userInfo\n");
+      return OO_FAILED;
+   }
+   memset(q931msg->userInfo, 0, sizeof(H225H323_UserInformation));
+
+   setup = (H225Setup_UUIE*) memAlloc(pctxt, sizeof(H225Setup_UUIE));
+   if(!setup)
+   {
+      OOTRACEERR3("Error:Memory -  ooH323MakeCall_helper - setup (%s, %s)\n",
+                 call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   memset (setup, 0, sizeof(H225Setup_UUIE));
+   setup->protocolIdentifier = gProtocolID;
+   
+   /* Populate Alias Address.*/
+
+   if(call->ourAliases || gH323ep.aliases)
+   {   
+      setup->m.sourceAddressPresent = TRUE;
+      if(call->ourAliases)
+         ret = ooPopulateAliasList(pctxt, call->ourAliases, 
+                                                       &setup->sourceAddress);
+      else if(gH323ep.aliases)
+         ret =  ooPopulateAliasList(pctxt, gH323ep.aliases, 
+                                                       &setup->sourceAddress);
+      if(OO_OK != ret)
+      {
+         OOTRACEERR1("Error:Failed to populate alias list in SETUP message\n");
+         memReset(pctxt);
+         return OO_FAILED;
+      }
+   }
+
+   setup->m.presentationIndicatorPresent = TRUE;
+   setup->presentationIndicator.t = 
+                             T_H225PresentationIndicator_presentationAllowed;
+   setup->m.screeningIndicatorPresent = TRUE;
+   setup->screeningIndicator = userProvidedNotScreened;
+
+   setup->m.multipleCallsPresent = TRUE;
+   setup->multipleCalls = FALSE;
+   setup->m.maintainConnectionPresent = TRUE;
+   setup->maintainConnection = FALSE;
+
+   /* Populate Destination aliases */
+   if(call->remoteAliases)
+   {
+      setup->m.destinationAddressPresent = TRUE;
+      ret = ooPopulateAliasList(pctxt, call->remoteAliases, 
+                                                 &setup->destinationAddress);
+      if(OO_OK != ret)
+      {
+         OOTRACEERR1("Error:Failed to populate destination alias list in SETUP"
+                     "message\n");
+         memReset(pctxt);
+         return OO_FAILED;
+      }
+   }
+
+   /* Populate the vendor information */
+   if(gH323ep.isGateway)
+      setup->sourceInfo.m.gatewayPresent = TRUE;
+   else
+      setup->sourceInfo.m.terminalPresent = TRUE;
+
+   setup->sourceInfo.m.vendorPresent=TRUE;
+   setup->sourceInfo.vendor.vendor.t35CountryCode = gH323ep.t35CountryCode;
+   setup->sourceInfo.vendor.vendor.t35Extension = gH323ep.t35Extension;
+   setup->sourceInfo.vendor.vendor.manufacturerCode= gH323ep.manufacturerCode;
+   
+   if(gH323ep.productID)
+   {
+      setup->sourceInfo.vendor.m.productIdPresent=TRUE;
+      setup->sourceInfo.vendor.productId.numocts = ASN1MIN(
+                              strlen(gH323ep.productID), 
+                              sizeof(setup->sourceInfo.vendor.productId.data));
+      strncpy((char*)setup->sourceInfo.vendor.productId.data, 
+                gH323ep.productID, setup->sourceInfo.vendor.productId.numocts);
+   }
+   else
+      setup->sourceInfo.vendor.m.productIdPresent=FALSE;
+   
+   if(gH323ep.versionID)
+   {
+      setup->sourceInfo.vendor.m.versionIdPresent=TRUE;
+      setup->sourceInfo.vendor.versionId.numocts = ASN1MIN(
+                              strlen(gH323ep.versionID), 
+                              sizeof(setup->sourceInfo.vendor.versionId.data));
+      strncpy((char*)setup->sourceInfo.vendor.versionId.data, 
+              gH323ep.versionID, setup->sourceInfo.vendor.versionId.numocts);
+   }
+   else
+      setup->sourceInfo.vendor.m.versionIdPresent=FALSE;
+   
+   setup->sourceInfo.mc = FALSE;
+   setup->sourceInfo.undefinedNode = FALSE;
+
+   /* Populate the destination Call Signal Address */
+   setup->destCallSignalAddress.t=T_H225TransportAddress_ipAddress;
+   destCallSignalIpAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt,
+                                  sizeof(H225TransportAddress_ipAddress));
+   if(!destCallSignalIpAddress)
+   {
+      OOTRACEERR3("Error:Memory -  ooH323MakeCall_helper - "
+                 "destCallSignalAddress. (%s, %s)\n", call->callType, 
+                 call->callToken);
+      return OO_FAILED;
+   }
+   ooSocketConvertIpToNwAddr(call->remoteIP, destCallSignalIpAddress->ip.data);
+
+   destCallSignalIpAddress->ip.numocts=4;
+   destCallSignalIpAddress->port = call->remotePort;
+
+   setup->destCallSignalAddress.u.ipAddress = destCallSignalIpAddress;
+   setup->m.destCallSignalAddressPresent=TRUE;
+   setup->activeMC=FALSE;
+
+   /* Populate the source Call Signal Address */
+   setup->sourceCallSignalAddress.t=T_H225TransportAddress_ipAddress;
+   srcCallSignalIpAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt,
+                                  sizeof(H225TransportAddress_ipAddress));
+   if(!srcCallSignalIpAddress)
+   {
+      OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - srcCallSignalAddress"
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   ooSocketConvertIpToNwAddr(call->localIP, srcCallSignalIpAddress->ip.data);
+
+   srcCallSignalIpAddress->ip.numocts=4;
+   srcCallSignalIpAddress->port= call->pH225Channel->port;
+   setup->sourceCallSignalAddress.u.ipAddress = srcCallSignalIpAddress;
+   setup->m.sourceCallSignalAddressPresent=TRUE;
+   /* No fast start */
+   if(!OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART))
+   {
+      setup->m.fastStartPresent = FALSE;
+   }
+   else{
+      setup->m.fastStartPresent = TRUE;
+      pFS = (ASN1DynOctStr*)memAlloc(pctxt, gH323ep.noOfCaps*
+                                       sizeof(ASN1DynOctStr));
+      if(!pFS)
+      {
+         OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - pFS(%s, %s)\n",
+                     call->callType, call->callToken);
+         return OO_FAILED;
+      }
+
+      /* Use preference order of codecs */
+      i=0;
+      for(k=0; k< call->capPrefs.index; k++)
+      {
+         OOTRACEDBGC5("Preffered capability at index %d is %s. (%s, %s)\n",
+                      k, ooGetCapTypeText(call->capPrefs.order[k]), 
+                      call->callType, call->callToken);
+
+         if(call->ourCaps) {
+            epCap = call->ourCaps;
+            OOTRACEDBGC3("Using call specific capabilities in faststart of "
+                         "setup message. (%s, %s)\n", call->callType, 
+                         call->callToken);
+         }
+         else{
+            epCap = gH323ep.myCaps;
+            OOTRACEDBGC3("Using end-point capabilities for faststart of setup"
+                         "message. (%s, %s)\n", call->callType, 
+                         call->callToken);
+         }
+
+         while(epCap){
+            if(epCap->cap == call->capPrefs.order[k]) break;
+            else epCap = epCap->next;
+         }
+         if(!epCap)
+         {
+            OOTRACEWARN4("Warn:Preferred capability %s is abscent in "
+                         "capability list. (%s, %s)\n", 
+                         ooGetCapTypeText(call->capPrefs.order[k]), 
+                         call->callType, call->callToken);
+            continue;
+         }
+
+
+
+         OOTRACEDBGC4("Building olcs with capability %s. (%s, %s)\n", 
+                      ooGetCapTypeText(epCap->cap), call->callType, 
+                      call->callToken);
+         if(epCap->dir & OORX)
+         {
+            olc = (H245OpenLogicalChannel*)memAlloc(pctxt, 
+                                             sizeof(H245OpenLogicalChannel));
+            if(!olc)
+            {
+               OOTRACEERR3("ERROR:Memory - ooH323MakeCall_helper - olc(%s, %s)"
+                           "\n", call->callType, call->callToken);
+               ooFreeQ931Message(q931msg);
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_LOCAL_CLEARED;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+            memset(olc, 0, sizeof(H245OpenLogicalChannel));
+            olc->forwardLogicalChannelNumber = call->logicalChanNoCur++; 
+            if(call->logicalChanNoCur > call->logicalChanNoMax)
+               call->logicalChanNoCur = call->logicalChanNoBase;
+        
+            ooBuildFastStartOLC(call, olc, epCap, pctxt, OORX);
+            /* Do not specify msg buffer let automatic allocation work */
+            setPERBuffer(pctxt, NULL, 0, aligned);
+            if(asn1PE_H245OpenLogicalChannel(pctxt, olc) != ASN_OK)
+            {
+               OOTRACEERR3("ERROR:Encoding of olc failed for faststart(%s, %s)"
+                           "\n", call->callType, call->callToken);
+               ooFreeQ931Message(q931msg);
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_LOCAL_CLEARED;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+            pFS[i].data = encodeGetMsgPtr(pctxt, &(pFS[i].numocts));
+
+
+            /* Dump faststart element in logfile for debugging purpose */
+            setPERBuffer(pctxt,  (char*)pFS[i].data, pFS[i].numocts, 1);
+            initializePrintHandler(&printHandler, "FastStart Element");
+            setEventHandler (pctxt, &printHandler);
+            memset(&printOlc, 0, sizeof(printOlc));
+            ret = asn1PD_H245OpenLogicalChannel(pctxt, &(printOlc));
+            if(ret != ASN_OK)
+            {
+               OOTRACEERR3("Error: Failed decoding FastStart Element."
+                           "(%s, %s)\n", call->callType, call->callToken);
+               ooFreeQ931Message(q931msg);
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_LOCAL_CLEARED;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+            finishPrint();
+            removeEventHandler(pctxt); 
+
+
+            olc = NULL;
+            i++;
+            OOTRACEDBGC5("Added RX fs element %d with capability %s(%s, %s)\n",
+                          i, ooGetCapTypeText(epCap->cap), call->callType, 
+                          call->callToken);
+         }
+
+         if(epCap->dir & OOTX)
+         {
+            olc = (H245OpenLogicalChannel*)memAlloc(pctxt, 
+                                             sizeof(H245OpenLogicalChannel));
+            if(!olc)
+            {
+               OOTRACEERR3("ERROR:Memory - ooH323MakeCall_helper - olc(%s, %s)"
+                           "\n", call->callType, call->callToken);
+               ooFreeQ931Message(q931msg);
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_LOCAL_CLEARED;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+            memset(olc, 0, sizeof(H245OpenLogicalChannel));
+            olc->forwardLogicalChannelNumber = call->logicalChanNoCur++; 
+            if(call->logicalChanNoCur > call->logicalChanNoMax)
+               call->logicalChanNoCur = call->logicalChanNoBase;
+        
+            ooBuildFastStartOLC(call, olc, epCap, pctxt, OOTX);
+            /* Do not specify msg buffer let automatic allocation work */
+            setPERBuffer(pctxt, NULL, 0, aligned);
+            if(asn1PE_H245OpenLogicalChannel(pctxt, olc) != ASN_OK)
+            {
+               OOTRACEERR3("ERROR:Encoding of olc failed for faststart(%s, %s)"
+                           "\n", call->callType, call->callToken);
+               ooFreeQ931Message(q931msg);
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_LOCAL_CLEARED;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+            pFS[i].data = encodeGetMsgPtr(pctxt, &(pFS[i].numocts));
+
+            /* Dump faststart element in logfile for debugging purpose */
+            setPERBuffer(pctxt,  (char*)pFS[i].data, pFS[i].numocts, 1);
+            initializePrintHandler(&printHandler, "FastStart Element");
+            setEventHandler (pctxt, &printHandler);
+            memset(&printOlc, 0, sizeof(printOlc));
+            ret = asn1PD_H245OpenLogicalChannel(pctxt, &(printOlc));
+            if(ret != ASN_OK)
+            {
+               OOTRACEERR3("Error: Failed decoding FastStart Element."
+                           "(%s, %s)\n", call->callType, call->callToken);
+               ooFreeQ931Message(q931msg);
+               if(call->callState < OO_CALL_CLEAR)
+               {
+                  call->callEndReason = OO_REASON_LOCAL_CLEARED;
+                  call->callState = OO_CALL_CLEAR;
+               }
+               return OO_FAILED;
+            }
+            finishPrint();
+            removeEventHandler(pctxt); 
+
+
+            olc = NULL;
+            i++;
+            OOTRACEDBGC5("Added TX fs element %d with capability %s(%s, %s)\n",
+                          i, ooGetCapTypeText(epCap->cap), call->callType, 
+                          call->callToken);
+         }
+
+      }
+      OOTRACEDBGA4("Added %d fast start elements to SETUP message (%s, %s)\n",
+                   i, call->callType, call->callToken);
+      setup->fastStart.n = i;
+      setup->fastStart.elem = pFS; 
+   }
+
+   setup->conferenceID.numocts= call->confIdentifier.numocts;
+   memcpy(setup->conferenceID.data, call->confIdentifier.data,
+          call->confIdentifier.numocts);
+
+   setup->conferenceGoal.t = T_H225Setup_UUIE_conferenceGoal_create;
+   /* H.225 point to point call */
+   setup->callType.t = T_H225CallType_pointToPoint;
+ 
+   /* Populate optional fields */
+   setup->m.callIdentifierPresent = TRUE;
+   /*ooGenerateCallIdentifier(&setup->callIdentifier);*/
+   setup->callIdentifier.guid.numocts = call->callIdentifier.guid.numocts;
+   memcpy(setup->callIdentifier.guid.data, call->callIdentifier.guid.data, 
+                               call->callIdentifier.guid.numocts);
+   
+   setup->m.mediaWaitForConnectPresent = TRUE;
+   if(OO_TESTFLAG(call->flags, OO_M_MEDIAWAITFORCONN)) {
+      setup->mediaWaitForConnect = TRUE;
+   }
+   else {
+      setup->mediaWaitForConnect = FALSE;
+   }
+   setup->m.canOverlapSendPresent = TRUE;
+   setup->canOverlapSend = FALSE;
+
+   /* Populate the userInfo structure with the setup UUIE */ 
+   
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+         T_H225H323_UU_PDU_h323_message_body_setup;
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.u.setup = setup;
+   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; 
+   
+   q931msg->userInfo->h323_uu_pdu.h245Tunneling = 
+      OO_TESTFLAG (call->flags, OO_M_TUNNELING);
+
+   /* For H.323 version 4 and higher, if fast connect, tunneling should be 
+      supported.
+   */
+   if(OO_TESTFLAG(call->flags, OO_M_FASTSTART))
+      q931msg->userInfo->h323_uu_pdu.h245Tunneling = TRUE;
+
+   OOTRACEDBGA3("Built SETUP message (%s, %s)\n", call->callType, 
+                 call->callToken);
+   
+   /* H225 message callback */
+   if(gH323ep.h225Callbacks.onBuiltSetup)
+      gH323ep.h225Callbacks.onBuiltSetup(call, q931msg);
+
+   ret=ooSendH225Msg(call, q931msg);
+   if(ret != OO_OK)
+   {
+     OOTRACEERR3("Error:Failed to enqueue SETUP message to outbound queue. (%s, %s)\n", call->callType, call->callToken);
+   }
+   memReset(&gH323ep.msgctxt);
+
+   return ret;
+}
+
+
+
+int ooQ931SendDTMFAsKeyPadIE(OOH323CallData *call, const char* data)
+{
+   int ret;    
+   H225Information_UUIE *information=NULL;
+   Q931Message *q931msg=NULL;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   ret = ooCreateQ931Message(&q931msg, Q931InformationMsg);
+   if(ret != OO_OK)
+   {      
+      OOTRACEERR3("Error: In allocating memory for - H225 Information message."
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   q931msg->callReference = call->callReference;
+
+   q931msg->userInfo = (H225H323_UserInformation*)memAllocZ(pctxt,
+                             sizeof(H225H323_UserInformation));
+   if(!q931msg->userInfo)
+   {
+      OOTRACEERR3("ERROR:Memory -  ooQ931SendDTMFAsKeypadIE - userInfo"
+                  "(%s, %s)\n", call->callType, call->callToken);
+      memReset(&gH323ep.msgctxt);
+      return OO_FAILED;
+   }
+   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; 
+   q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG(gH323ep.flags, 
+                                                              OO_M_TUNNELING); 
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+         T_H225H323_UU_PDU_h323_message_body_information;
+   
+   information = (H225Information_UUIE*)memAllocZ(pctxt, 
+                                             sizeof(H225Information_UUIE));
+   if(!information)
+   {
+      OOTRACEERR3("ERROR:Memory -  ooQ931SendDTMFAsKeypadIE - information"
+                  "(%s, %s)\n", call->callType, call->callToken);
+      memReset(&gH323ep.msgctxt);
+      return OO_FAILED;
+   }
+   q931msg->userInfo->h323_uu_pdu.h323_message_body.u.information = 
+                                                                  information; 
+   information->m.callIdentifierPresent = 1;
+   information->callIdentifier.guid.numocts = 
+                                   call->callIdentifier.guid.numocts;
+   memcpy(information->callIdentifier.guid.data, 
+          call->callIdentifier.guid.data, 
+          call->callIdentifier.guid.numocts);
+   information->protocolIdentifier = gProtocolID;
+   
+   /*Add keypad IE*/
+   ret = ooQ931SetKeypadIE(q931msg, data);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Creating keypad IE for (%s, %s)\n", call->callType, 
+                   call->callToken);
+      memReset(&gH323ep.msgctxt);
+      return OO_FAILED;
+   }
+
+   ret=ooSendH225Msg(call, q931msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("Error:Failed to enqueue Information message to outbound "
+                  "queue. (%s, %s)\n", call->callType, call->callToken);
+   }
+   memReset(&gH323ep.msgctxt);
+
+   return ret;
+
+}
+
+int ooH323ForwardCall(char* callToken, char *dest)
+{
+   int ret=0;
+   Q931Message *pQ931Msg = NULL;
+   H225Facility_UUIE *facility=NULL;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+   OOH323CallData *call;
+   char ip[30]="\0", *pcPort=NULL;
+   H225TransportAddress_ipAddress *fwdCallSignalIpAddress;
+
+   call= ooFindCallByToken(callToken);
+   if(!call)
+   {
+      OOTRACEERR2("ERROR: Invalid call token for forward - %s\n", callToken);
+      return OO_FAILED;
+   }
+   OOTRACEDBGA3("Building Facility message for call forward (%s, %s)\n", 
+                                              call->callType, call->callToken);
+   call->pCallFwdData = (OOCallFwdData*)memAllocZ(call->pctxt, 
+                                                     sizeof(OOCallFwdData));
+   if(!call->pCallFwdData)
+   {
+     OOTRACEERR3("Error:Memory - ooH323ForwardCall - pCallFwdData (%s, %s)\n",
+     call->callType, call->callToken);
+     return OO_FAILED;
+   }
+
+   ret = ooParseDestination(call, dest, ip, 20, 
+                                             &call->pCallFwdData->aliases);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR4("Error:Failed to parse the destination %s for call fwd."
+                  "(%s, %s)\n", dest, call->callType, call->callToken);
+      memFreePtr(call->pctxt, call->pCallFwdData);
+      return OO_FAILED;
+   }
+
+   if(!ooUtilsIsStrEmpty(ip))
+   {
+      pcPort = strchr(ip, ':');
+      if(pcPort)
+      {
+         *pcPort = '\0';
+         pcPort++;
+         call->pCallFwdData->port = atoi(pcPort);
+      }
+      strcpy(call->pCallFwdData->ip, ip);
+   }
+
+   ret = ooCreateQ931Message(&pQ931Msg, Q931FacilityMsg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3
+         ("ERROR: In allocating memory for call transfer facility message "
+          "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   pQ931Msg->callReference = call->callReference;
+
+   pQ931Msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt,
+                             sizeof(H225H323_UserInformation));
+   if(!pQ931Msg->userInfo)
+   {
+      OOTRACEERR3("ERROR:Memory - ooH323ForwardCall - userInfo(%s, %s)\n", 
+                   call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   memset (pQ931Msg->userInfo, 0, sizeof(H225H323_UserInformation));
+   pQ931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; 
+
+   pQ931Msg->userInfo->h323_uu_pdu.h245Tunneling = 
+                                   OO_TESTFLAG (call->flags, OO_M_TUNNELING); 
+
+   pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+      T_H225H323_UU_PDU_h323_message_body_facility;
+   
+   facility = (H225Facility_UUIE*) 
+      memAllocZ (pctxt, sizeof(H225Facility_UUIE));
+
+   if(!facility)
+   {
+      OOTRACEERR3("ERROR:Memory - ooH323ForwardCall - facility (%s, %s)"
+                  "\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.u.facility = facility;
+   
+   facility->protocolIdentifier = gProtocolID;  
+   facility->m.callIdentifierPresent = 1;
+   facility->callIdentifier.guid.numocts = 
+      call->callIdentifier.guid.numocts;
+
+   memcpy(facility->callIdentifier.guid.data, 
+          call->callIdentifier.guid.data, 
+          call->callIdentifier.guid.numocts);
+
+   facility->reason.t = T_H225FacilityReason_callForwarded;
+   
+   if(!ooUtilsIsStrEmpty(call->pCallFwdData->ip))
+   {
+      facility->m.alternativeAddressPresent = TRUE;
+      facility->alternativeAddress.t=T_H225TransportAddress_ipAddress;
+      fwdCallSignalIpAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt,
+                                  sizeof(H225TransportAddress_ipAddress));
+      if(!fwdCallSignalIpAddress)
+      {
+         OOTRACEERR3("Error:Memory - ooH323ForwardCall - fwdCallSignalAddress"
+                     "(%s, %s)\n", call->callType, call->callToken);
+         return OO_FAILED;
+      }
+      ooSocketConvertIpToNwAddr(call->pCallFwdData->ip, 
+                                          fwdCallSignalIpAddress->ip.data);
+
+      fwdCallSignalIpAddress->ip.numocts=4;
+      fwdCallSignalIpAddress->port = call->pCallFwdData->port;
+      facility->alternativeAddress.u.ipAddress = fwdCallSignalIpAddress;
+   }
+
+   if(call->pCallFwdData->aliases)
+   {    
+      facility->m.alternativeAliasAddressPresent = TRUE;
+      ret = ooPopulateAliasList(pctxt, call->pCallFwdData->aliases, 
+                                        &facility->alternativeAliasAddress);
+      if(ret != OO_OK)
+      {
+         OOTRACEERR3("Error:Failed to populate alternate aliases in "
+                     "ooH323ForwardCall. (%s, %s)\n", call->callType, 
+                     call->callToken);
+         return OO_FAILED;
+      }
+   }
+
+   ret = ooSendH225Msg(call, pQ931Msg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3
+         ("Error:Failed to enqueue Forward Facility message to outbound "
+         "queue.(%s, %s)\n", call->callType, call->callToken);
+   }
+   call->callEndReason = OO_REASON_LOCAL_FWDED;
+   memReset (&gH323ep.msgctxt);
+   return ret;
+}
+
+int ooH323HangCall(char * callToken, OOCallClearReason reason)
+{
+   OOH323CallData *call;
+
+   call= ooFindCallByToken(callToken);
+   if(!call)
+   {
+      OOTRACEWARN2("WARN: Call hangup failed - Call %s not present\n", 
+                    callToken);
+      return OO_FAILED;
+   }
+   OOTRACEINFO3("Hanging up call (%s, %s)\n", call->callType, call->callToken);
+   if(call->callState < OO_CALL_CLEAR)
+   {
+      call->callEndReason = reason;
+      call->callState = OO_CALL_CLEAR;
+   }
+   return OO_OK;
+}
+
+int ooSetBearerCapabilityIE
+   (Q931Message *pmsg, enum Q931CodingStandard codingStandard, 
+    enum Q931InformationTransferCapability capability, 
+    enum Q931TransferMode transferMode, enum Q931TransferRate transferRate,
+    enum Q931UserInfoLayer1Protocol userInfoLayer1)
+{
+   unsigned size = 3;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   if(pmsg->bearerCapabilityIE)
+   {
+      memFreePtr(pctxt, pmsg->bearerCapabilityIE);
+      pmsg->bearerCapabilityIE = NULL;
+   }
+
+   pmsg->bearerCapabilityIE = (Q931InformationElement*) 
+                      memAlloc(pctxt, sizeof(Q931InformationElement)+size-1);
+   if(!pmsg->bearerCapabilityIE)
+   {
+      OOTRACEERR1("Error:Memory - ooSetBearerCapabilityIE - bearerCapabilityIE"
+                  "\n");
+      return OO_FAILED;
+   }
+
+   pmsg->bearerCapabilityIE->discriminator = Q931BearerCapabilityIE;
+   pmsg->bearerCapabilityIE->length = size;
+   pmsg->bearerCapabilityIE->data[0] = (ASN1OCTET)(0x80 | ((codingStandard&3) << 5) | (capability&31));
+
+   pmsg->bearerCapabilityIE->data[1] = (0x80 | ((transferMode & 3) << 5) | (transferRate & 31));
+   
+   pmsg->bearerCapabilityIE->data[2] = (0x80 | (1<<5) | userInfoLayer1);
+
+   return OO_OK;
+}
+
+int ooQ931SetKeypadIE(Q931Message *pmsg, const char* data)
+{
+   unsigned len = 0;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   len = strlen(data);
+   pmsg->keypadIE = (Q931InformationElement*) 
+                      memAlloc(pctxt, sizeof(Q931InformationElement)+len-1);
+   if(!pmsg->keypadIE)
+   {
+      OOTRACEERR1("Error:Memory - ooQ931SetKeypadIE - keypadIE\n");
+      return OO_FAILED;
+   }
+
+   pmsg->keypadIE->discriminator = Q931KeypadIE;
+   pmsg->keypadIE->length = len;
+   memcpy(pmsg->keypadIE->data, data, len);
+   return OO_OK;
+}
+
+
+
+
+int ooQ931SetCallingPartyNumberIE
+   (Q931Message *pmsg, const char *number, unsigned plan, unsigned type, 
+    unsigned presentation, unsigned screening)
+{
+   unsigned len = 0;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   if(pmsg->callingPartyNumberIE)
+   {
+      memFreePtr(pctxt, pmsg->callingPartyNumberIE);
+      pmsg->callingPartyNumberIE = NULL;
+   }
+
+   len = strlen(number);
+   pmsg->callingPartyNumberIE = (Q931InformationElement*) 
+                      memAlloc(pctxt, sizeof(Q931InformationElement)+len+2-1);
+   if(!pmsg->callingPartyNumberIE)
+   {
+      OOTRACEERR1("Error:Memory - ooQ931SetCallingPartyNumberIE - "
+                  "callingPartyNumberIE\n");
+      return OO_FAILED;
+   }
+   pmsg->callingPartyNumberIE->discriminator = Q931CallingPartyNumberIE;
+   pmsg->callingPartyNumberIE->length = len+2;
+   pmsg->callingPartyNumberIE->data[0] = (((type&7)<<4)|(plan&15));
+   pmsg->callingPartyNumberIE->data[1] = (0x80|((presentation&3)<<5)|(screening&3));
+   memcpy(pmsg->callingPartyNumberIE->data+2, number, len);
+
+   return OO_OK;
+}
+
+int ooQ931SetCalledPartyNumberIE
+   (Q931Message *pmsg, const char *number, unsigned plan, unsigned type)
+{
+   unsigned len = 0;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   if(pmsg->calledPartyNumberIE)
+   {
+      memFreePtr(pctxt, pmsg->calledPartyNumberIE);
+      pmsg->calledPartyNumberIE = NULL;
+   }
+
+   len = strlen(number);
+   pmsg->calledPartyNumberIE = (Q931InformationElement*) 
+                      memAlloc(pctxt, sizeof(Q931InformationElement)+len+1-1);
+   if(!pmsg->calledPartyNumberIE)
+   {
+      OOTRACEERR1("Error:Memory - ooQ931SetCalledPartyNumberIE - "
+                  "calledPartyNumberIE\n");
+      return OO_FAILED;
+   }
+   pmsg->calledPartyNumberIE->discriminator = Q931CalledPartyNumberIE;
+   pmsg->calledPartyNumberIE->length = len+1;
+   pmsg->calledPartyNumberIE->data[0] = (0x80|((type&7)<<4)|(plan&15));
+   memcpy(pmsg->calledPartyNumberIE->data+1, number, len);
+
+   return OO_OK;
+}
+
+int ooQ931SetCauseIE
+   (Q931Message *pmsg, enum Q931CauseValues cause, unsigned coding, 
+    unsigned location)
+{
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   if(pmsg->causeIE){
+      memFreePtr(pctxt, pmsg->causeIE);
+      pmsg->causeIE = NULL;
+   }
+
+   pmsg->causeIE = (Q931InformationElement*) 
+                      memAlloc(pctxt, sizeof(Q931InformationElement)+1);
+   if(!pmsg->causeIE)
+   {
+      OOTRACEERR1("Error:Memory - ooQ931SetCauseIE - causeIE\n");
+      return OO_FAILED;
+   }
+   pmsg->causeIE->discriminator = Q931CauseIE;
+   pmsg->causeIE->length = 2;
+   pmsg->causeIE->data[0] = (0x80 | ((coding & 0x03) <<5) | (location & 0x0F));
+
+   pmsg->causeIE->data[1] = (0x80 | cause);
+  
+   return OO_OK;
+}
+
+
+/* Build a Facility message and tunnel H.245 message through it */
+int ooSendAsTunneledMessage(OOH323CallData *call, ASN1OCTET* msgbuf, 
+                            int h245Len, int h245MsgType, int associatedChan)
+{
+   Q931Message *pQ931Msg = NULL;
+   H225H323_UU_PDU *pH323UUPDU = NULL;
+   H225H323_UU_PDU_h245Control *pH245Control = NULL;
+   ASN1DynOctStr * elem;
+   int ret =0;
+   H225Facility_UUIE *facility=NULL;
+   OOCTXT *pctxt = &gH323ep.msgctxt;
+
+   OOTRACEDBGA4("Building Facility message for tunneling %s (%s, %s)\n", 
+                 ooGetMsgTypeText(h245MsgType), call->callType, call->callToken);
+
+   ret = ooCreateQ931Message(&pQ931Msg, Q931FacilityMsg);
+   if(ret != OO_OK)
+   {
+      OOTRACEERR3("ERROR: In allocating memory for facility message "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+
+   pQ931Msg->callReference = call->callReference;
+
+   pQ931Msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt,
+                             sizeof(H225H323_UserInformation));
+   if(!pQ931Msg->userInfo)
+   {
+      OOTRACEERR3("ERROR:Memory - ooSendAsTunneledMessage - userInfo"
+                " (%s, %s)\n", call->callType, call->callToken);
+      memReset(&gH323ep.msgctxt);
+      return OO_FAILED;
+   }
+   memset (pQ931Msg->userInfo, 0, sizeof(H225H323_UserInformation));
+   pQ931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; 
+
+   pQ931Msg->userInfo->h323_uu_pdu.h245Tunneling = 
+      OO_TESTFLAG (call->flags, OO_M_TUNNELING);
+
+   pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.t = 
+         T_H225H323_UU_PDU_h323_message_body_facility;
+   
+   facility = (H225Facility_UUIE*)
+      memAllocZ (pctxt, sizeof(H225Facility_UUIE));
+
+   if(!facility)
+   {
+      OOTRACEERR3("ERROR:Memory - ooSendAsTunneledMessage - facility (%s, %s)"
+                  "\n", call->callType, call->callToken);
+      memReset(&gH323ep.msgctxt);
+      return OO_FAILED;
+   }
+
+   pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.u.facility = facility;
+   /* Populate Facility UUIE */
+   facility->protocolIdentifier = gProtocolID;  
+   facility->m.callIdentifierPresent = 1;
+   facility->callIdentifier.guid.numocts = 
+      call->callIdentifier.guid.numocts;
+
+   memcpy(facility->callIdentifier.guid.data, 
+          call->callIdentifier.guid.data, 
+          call->callIdentifier.guid.numocts);
+
+   facility->reason.t = T_H225FacilityReason_transportedInformation;
+
+   pH323UUPDU = (H225H323_UU_PDU*) &pQ931Msg->userInfo->h323_uu_pdu;
+   pH323UUPDU->m.h245TunnelingPresent = TRUE;
+   pH323UUPDU->m.h245ControlPresent = TRUE;
+   pH323UUPDU->h245Tunneling = TRUE;
+   pH245Control = (H225H323_UU_PDU_h245Control*)
+                   &pH323UUPDU->h245Control;
+
+   elem = (ASN1DynOctStr*) memAlloc(pctxt, 
+                                      sizeof(ASN1DynOctStr));
+   if(!elem)
+   {
+      OOTRACEERR3("ERROR:Memory - ooSendAsTunneledMessage - elem "
+                  "(%s, %s)\n", call->callType, call->callToken);
+      return OO_FAILED;
+   }
+   elem->data = msgbuf;
+   elem->numocts = h245Len;
+   pH245Control->elem = elem;
+   pH245Control->n = 1;
+   pQ931Msg->tunneledMsgType = h245MsgType;
+   pQ931Msg->logicalChannelNo = associatedChan;
+
+   
+   ret = ooSendH225Msg(call, pQ931Msg);
+   if(ret != OO_OK)
+   {
+     OOTRACEERR3("Error:Failed to enqueue Facility(tunneling) message to "
+                 "outbound queue.(%s, %s)\n", call->callType, call->callToken);
+   }
+
+   /* Can't do memReset here because if we are sending H.245 message as a 
+      response to received tunneled h.245 message, we can't reset unless the \
+      main received H225 message processing is finished. Rule. No reset when
+      tunneling
+   */
+   memFreePtr(&gH323ep.msgctxt, pQ931Msg);
+   return ret;
+}
+
+int ooCallEstbTimerExpired(void *data)
+{
+
+   ooTimerCallback *cbData = (ooTimerCallback*) data;
+   OOH323CallData *call = cbData->call;
+   OOTRACEINFO3("Call Establishment timer expired. (%s, %s)\n", 
+                                            call->callType, call->callToken); 
+   memFreePtr(call->pctxt, cbData);
+   if(call->callState < OO_CALL_CLEAR){
+      call->callState = OO_CALL_CLEAR;
+      call->callEndReason = OO_REASON_LOCAL_CLEARED;      
+   }
+
+   return OO_OK;
+}
+
+
+int ooQ931GetCauseAndReasonCodeFromCallClearReason
+   (OOCallClearReason clearReason, enum Q931CauseValues *cause, 
+    unsigned *reasonCode)
+{
+   switch(clearReason)
+   {
+   case OO_REASON_INVALIDMESSAGE:
+   case OO_REASON_TRANSPORTFAILURE:
+      *reasonCode =  T_H225ReleaseCompleteReason_undefinedReason;
+      *cause = Q931ProtocolErrorUnspecified;
+      break;
+   case OO_REASON_NOBW:
+      *reasonCode = T_H225ReleaseCompleteReason_noBandwidth;
+      *cause = Q931ErrorInCauseIE;
+      break;
+   case OO_REASON_GK_NOCALLEDUSER:
+      *reasonCode = T_H225ReleaseCompleteReason_calledPartyNotRegistered;
+      *cause = Q931SubscriberAbsent;
+      break;
+   case OO_REASON_GK_NOCALLERUSER:
+      *reasonCode = T_H225ReleaseCompleteReason_callerNotRegistered;
+      *cause = Q931SubscriberAbsent;      
+      break;
+   case OO_REASON_GK_UNREACHABLE:
+      *reasonCode = T_H225ReleaseCompleteReason_unreachableGatekeeper;
+      *cause = Q931TemporaryFailure;
+      break;
+   case OO_REASON_GK_NORESOURCES:
+   case OO_REASON_GK_CLEARED:
+      *reasonCode = T_H225ReleaseCompleteReason_gatekeeperResources;
+      *cause = Q931Congestion;
+      break;
+   case OO_REASON_NOCOMMON_CAPABILITIES:
+      *reasonCode =  T_H225ReleaseCompleteReason_undefinedReason;
+      *cause = Q931IncompatibleDestination;
+      break;
+   case OO_REASON_LOCAL_FWDED:
+   case OO_REASON_REMOTE_FWDED:
+      *reasonCode =  T_H225ReleaseCompleteReason_facilityCallDeflection;
+      *cause = Q931Redirection;
+      break;
+   case OO_REASON_REMOTE_CLEARED:
+   case OO_REASON_LOCAL_CLEARED:
+      *reasonCode = T_H225ReleaseCompleteReason_undefinedReason;
+      *cause = Q931NormalCallClearing;
+      break;
+   case OO_REASON_REMOTE_BUSY:
+   case OO_REASON_LOCAL_BUSY:
+      *reasonCode =  T_H225ReleaseCompleteReason_inConf;
+      *cause = Q931UserBusy;
+      break;
+   case OO_REASON_REMOTE_NOANSWER:
+   case OO_REASON_LOCAL_NOTANSWERED:
+      *reasonCode =  T_H225ReleaseCompleteReason_undefinedReason;
+      *cause = Q931NoAnswer;
+      break;
+   case OO_REASON_REMOTE_REJECTED:
+   case OO_REASON_LOCAL_REJECTED:
+      *reasonCode = T_H225ReleaseCompleteReason_destinationRejection;
+      *cause = Q931CallRejected;
+      break;
+   case OO_REASON_REMOTE_CONGESTED:
+   case OO_REASON_LOCAL_CONGESTED:
+      *reasonCode =  T_H225ReleaseCompleteReason_noBandwidth;
+      *cause = Q931Congestion;
+      break;
+   case OO_REASON_NOROUTE:
+      *reasonCode = T_H225ReleaseCompleteReason_unreachableDestination;
+      *cause = Q931NoRouteToDestination;
+      break;
+   case OO_REASON_NOUSER:
+      *reasonCode = T_H225ReleaseCompleteReason_undefinedReason;      
+      *cause = Q931SubscriberAbsent;
+      break;
+   case OO_REASON_UNKNOWN:
+   default:
+      *reasonCode = T_H225ReleaseCompleteReason_undefinedReason;
+      *cause = Q931NormalUnspecified;
+   }
+
+   return OO_OK;
+}
+
+enum OOCallClearReason ooGetCallClearReasonFromCauseAndReasonCode
+   (enum Q931CauseValues cause, unsigned reasonCode)
+{
+   switch(cause)
+   {
+      case Q931NormalCallClearing:
+         return OO_REASON_REMOTE_CLEARED;
+
+      case Q931UserBusy:
+         return OO_REASON_REMOTE_BUSY;
+
+      case Q931NoResponse:
+      case Q931NoAnswer:
+         return OO_REASON_REMOTE_NOANSWER;
+
+      case Q931CallRejected:
+         return OO_REASON_REMOTE_REJECTED;
+
+      case Q931Redirection:
+         return OO_REASON_REMOTE_FWDED;
+
+      case Q931NetworkOutOfOrder:
+      case Q931TemporaryFailure:
+         return OO_REASON_TRANSPORTFAILURE;
+
+      case Q931NoCircuitChannelAvailable:
+      case Q931Congestion:
+      case Q931RequestedCircuitUnAvailable:
+      case Q931ResourcesUnavailable:
+         return OO_REASON_REMOTE_CONGESTED;
+
+      case Q931NoRouteToDestination:
+      case Q931NoRouteToNetwork:
+         return OO_REASON_NOROUTE;
+      case Q931NumberChanged:
+      case Q931UnallocatedNumber:
+      case Q931SubscriberAbsent:
+         return OO_REASON_NOUSER;
+      case Q931ChannelUnacceptable:
+      case Q931DestinationOutOfOrder:
+      case Q931InvalidNumberFormat:
+      case Q931NormalUnspecified:
+      case Q931StatusEnquiryResponse:
+      case Q931IncompatibleDestination:
+      case Q931ProtocolErrorUnspecified:
+      case Q931RecoveryOnTimerExpiry:
+      case Q931InvalidCallReference:
+      default:
+         switch(reasonCode)
+         {
+            case T_H225ReleaseCompleteReason_noBandwidth:
+               return OO_REASON_NOBW;
+            case T_H225ReleaseCompleteReason_gatekeeperResources:
+               return OO_REASON_GK_NORESOURCES;
+            case T_H225ReleaseCompleteReason_unreachableDestination:
+               return OO_REASON_NOROUTE;
+            case T_H225ReleaseCompleteReason_destinationRejection:
+               return OO_REASON_REMOTE_REJECTED;
+            case T_H225ReleaseCompleteReason_inConf:
+               return OO_REASON_REMOTE_BUSY;
+            case T_H225ReleaseCompleteReason_facilityCallDeflection:
+               return OO_REASON_REMOTE_FWDED;
+            case T_H225ReleaseCompleteReason_calledPartyNotRegistered:
+               return OO_REASON_GK_NOCALLEDUSER;
+            case T_H225ReleaseCompleteReason_callerNotRegistered:
+               return OO_REASON_GK_NOCALLERUSER;
+            case T_H225ReleaseCompleteReason_gatewayResources:
+               return OO_REASON_GK_NORESOURCES;
+            case T_H225ReleaseCompleteReason_unreachableGatekeeper:
+               return OO_REASON_GK_UNREACHABLE;
+            case T_H225ReleaseCompleteReason_invalidRevision:
+            case T_H225ReleaseCompleteReason_noPermission:
+            case T_H225ReleaseCompleteReason_badFormatAddress:
+            case T_H225ReleaseCompleteReason_adaptiveBusy:
+            case T_H225ReleaseCompleteReason_undefinedReason:
+            case T_H225ReleaseCompleteReason_securityDenied:
+            case T_H225ReleaseCompleteReason_newConnectionNeeded:
+            case T_H225ReleaseCompleteReason_nonStandardReason:
+            case T_H225ReleaseCompleteReason_replaceWithConferenceInvite:
+            case T_H225ReleaseCompleteReason_genericDataReason:
+            case T_H225ReleaseCompleteReason_neededFeatureNotSupported:
+            case T_H225ReleaseCompleteReason_tunnelledSignallingRejected:
+            case T_H225ReleaseCompleteReason_invalidCID:
+            case T_H225ReleaseCompleteReason_securityError:
+            case T_H225ReleaseCompleteReason_hopCountExceeded:
+            case T_H225ReleaseCompleteReason_extElem1:
+            default:
+               return OO_REASON_UNKNOWN;
+         }
+   }
+   return OO_REASON_UNKNOWN;
+}
+
+/**
+ This function is used to parse destination string passed to ooH323MakeCall and
+ ooH323ForwardCall. If the string contains ip address and port, it is returned
+ in the parsedIP buffer and if it contains alias, it is added to aliasList
+*/
+int ooParseDestination
+   (struct OOH323CallData *call, char *dest, char* parsedIP, unsigned len,
+    ooAliases** aliasList)
+{
+   int iEk=-1, iDon=-1, iTeen=-1, iChaar=-1, iPort = -1, i;
+   ooAliases * psNewAlias = NULL;
+   char *cAt = NULL, *host=NULL;
+   char tmp[256], buf[30];
+   char *alias=NULL;
+   OOCTXT *pctxt = call->pctxt;
+   parsedIP[0] = '\0';
+
+   OOTRACEINFO2("Parsing destination %s\n", dest);
+  
+   /* Test for an IP address:Note that only supports dotted IPv4.
+      IPv6 won't pass the test and so will numeric IP representation*/
+   
+   sscanf(dest, "%d.%d.%d.%d:%d", &iEk, &iDon, &iTeen, &iChaar, &iPort);
+   if((iEk > 0            && iEk <= 255)    &&
+      (iDon >= 0          && iDon <= 255)   &&
+      (iTeen >=0          && iTeen <= 255)  &&
+      (iChaar >= 0        && iChaar <= 255) &&
+      (!strchr(dest, ':') || iPort != -1))
+   {
+      if(!strchr(dest, ':'))
+         iPort = 1720; /*Default h.323 port */
+
+      sprintf(buf, "%d.%d.%d.%d:%d", iEk, iDon, iTeen, iChaar, iPort);
+      if(strlen(buf)+1>len)
+      {
+         OOTRACEERR1("Error:Insufficient buffer space for parsed ip - "
+                     "ooParseDestination\n");
+         return OO_FAILED;
+      }
+         
+      strcpy(parsedIP, buf);
+      return OO_OK;
+   }
+
+   /* alias@host */
+   strncpy(tmp, dest, sizeof(tmp)-1);
+   tmp[sizeof(tmp)-1]='\0';
+   if((host=strchr(tmp, '@')) != NULL)
+   {
+      *host = '\0';
+      host++;
+      sscanf(host, "%d.%d.%d.%d:%d", &iEk, &iDon, &iTeen, &iChaar, &iPort);
+      if((iEk > 0            && iEk <= 255)    &&
+         (iDon >= 0          && iDon <= 255)   &&
+         (iTeen >=0          && iTeen <= 255)  &&
+         (iChaar >= 0        && iChaar <= 255) &&
+         (!strchr(host, ':') || iPort != -1))
+      {
+         if(!strchr(dest, ':'))
+            iPort = 1720; /*Default h.323 port */
+
+         sprintf(buf, "%d.%d.%d.%d:%d", iEk, iDon, iTeen, iChaar, iPort);
+         if(strlen(buf)+1>len)
+         {
+            OOTRACEERR1("Error:Insufficient buffer space for parsed ip - "
+                        "ooParseDestination\n");
+            return OO_FAILED;
+         }
+
+         strncpy(parsedIP, buf, len-1);
+         parsedIP[len-1]='\0';
+         alias = tmp;
+      }
+   }
+
+   if(!alias)
+   {
+     alias = dest;
+   }
+   /* url test */
+   if(alias == strstr(alias, "http://"))
+   {
+      psNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases));
+      if(!psNewAlias)
+      {
+         OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias\n");
+         return OO_FAILED;
+      }
+      psNewAlias->type = T_H225AliasAddress_url_ID;
+      psNewAlias->value = (char*) memAlloc(pctxt, strlen(alias)+1);
+      if(!psNewAlias->value)
+      {
+         OOTRACEERR1("Error:Memory - ooParseDestination - "
+                     "psNewAlias->value\n");
+         memFreePtr(pctxt, psNewAlias);
+         return OO_FAILED;
+      }
+      strcpy(psNewAlias->value, alias);
+      psNewAlias->next = *aliasList;
+      *aliasList = psNewAlias;
+      OOTRACEINFO2("Destination parsed as url %s\n", psNewAlias->value);
+      return OO_OK;
+   }
+
+   /* E-mail ID test */
+   if((cAt = strchr(alias, '@')) && alias != strchr(alias, '@'))
+   {
+      if(strchr(cAt, '.'))
+      {
+         psNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases));
+         if(!psNewAlias)
+         {
+            OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias\n");
+            return OO_FAILED;
+         }
+         psNewAlias->type = T_H225AliasAddress_email_ID;
+         psNewAlias->value = (char*) memAlloc(pctxt, strlen(alias)+1);
+         if(!psNewAlias->value)
+         {
+            OOTRACEERR1("Error:Memory - ooParseDestination - "
+                        "psNewAlias->value\n");
+            memFreePtr(pctxt, psNewAlias);
+            return OO_FAILED;
+         }
+         strcpy(psNewAlias->value, alias);
+         psNewAlias->next = *aliasList;
+         *aliasList = psNewAlias;
+         OOTRACEINFO2("Destination is parsed as email %s\n",psNewAlias->value);
+         return OO_OK;
+      }
+   }
+
+  
+   /* e-164 */
+   /* strspn(dest, "1234567890*#,") == strlen(dest)*/
+   /* Dialed digits test*/
+   for(i=0; *(alias+i) != '\0'; i++)
+   {
+      if(!isdigit(alias[i]) && alias[i] != '#' && alias[i] != '*' && 
+         alias[i] != ',')
+         break;
+   }
+   if(*(alias+i) == '\0')
+   {
+      psNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases));
+      if(!psNewAlias)
+      {
+         OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias\n");
+         return OO_FAILED;
+      }
+      /*      memset(psNewAlias, 0, sizeof(ooAliases));*/
+      psNewAlias->type = T_H225AliasAddress_dialedDigits;
+      psNewAlias->value = (char*) memAlloc(pctxt, strlen(alias)+1);
+      if(!psNewAlias->value)
+      {
+         OOTRACEERR1("Error:Memroy - ooParseDestination - "
+                     "psNewAlias->value\n");
+         memFreePtr(pctxt, psNewAlias);
+         return OO_FAILED;
+      }
+      strcpy(psNewAlias->value, alias);
+      psNewAlias->next = *aliasList;
+      *aliasList = psNewAlias;
+      OOTRACEINFO2("Destination is parsed as dialed digits %s\n",
+                  psNewAlias->value);
+      /* Also set called party number */
+      if(!call->calledPartyNumber)
+      {
+         if(ooCallSetCalledPartyNumber(call, alias) != OO_OK)
+         {
+            OOTRACEWARN3("Warning:Failed to set calling party number."
+                         "(%s, %s)\n", call->callType, call->callToken);
+         }
+      }
+      return OO_OK;
+   }
+   /* Evrything else is an h323-id for now */
+   psNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases));
+   if(!psNewAlias)
+   {
+      OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias\n");
+      return OO_FAILED;
+   }
+   psNewAlias->type = T_H225AliasAddress_h323_ID;
+   psNewAlias->value = (char*) memAlloc(pctxt, strlen(alias)+1);
+   if(!psNewAlias->value)
+   {
+      OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias->value\n");
+      memFreePtr(pctxt, psNewAlias);
+      return OO_FAILED;
+   }
+   strcpy(psNewAlias->value, alias);
+   psNewAlias->next = *aliasList;
+   *aliasList = psNewAlias;
+   OOTRACEINFO2("Destination for new call is parsed as h323-id %s \n",
+               psNewAlias->value);
+   return OO_OK;
+}
+
+const char* ooGetMsgTypeText (int msgType)
+{
+   static const char *msgTypeText[]={
+      "OOQ931MSG",
+      "OOH245MSG",
+      "OOSetup",
+      "OOCallProceeding",
+      "OOAlert",
+      "OOConnect",
+      "OOReleaseComplete",
+      "OOFacility",
+      "OOInformation",
+      "OOMasterSlaveDetermination",
+      "OOMasterSlaveAck",
+      "OOMasterSlaveReject",
+      "OOMasterSlaveRelease",
+      "OOTerminalCapabilitySet",
+      "OOTerminalCapabilitySetAck",
+      "OOTerminalCapabilitySetReject",
+      "OOTerminalCapabilitySetRelease",
+      "OOOpenLogicalChannel",
+      "OOOpenLogicalChannelAck",
+      "OOOpenLogicalChannelReject",
+      "OOOpenLogicalChannelRelease",
+      "OOOpenLogicalChannelConfirm",
+      "OOCloseLogicalChannel",
+      "OOCloseLogicalChannelAck",
+      "OORequestChannelClose",
+      "OORequestChannelCloseAck",
+      "OORequestChannelCloseReject",
+      "OORequestChannelCloseRelease",
+      "OOEndSessionCommand"
+   };
+   int idx = msgType - OO_MSGTYPE_MIN;
+   return ooUtilsGetText (idx, msgTypeText, OONUMBEROF(msgTypeText));
+}
+
+const char* ooGetQ931CauseValueText(int val)
+{
+   switch(val)
+   {
+      case Q931UnallocatedNumber:   
+         return "Q931UnallocatedNumber";
+      case Q931NoRouteToNetwork:
+         return "Q931NoRouteToNetwork";
+      case Q931NoRouteToDestination:
+         return "Q931NoRouteToDestination";
+      case Q931ChannelUnacceptable: 
+         return "Q931ChannelUnacceptable";
+      case Q931NormalCallClearing:
+         return "Q931NormalCallClearing";
+      case Q931UserBusy:
+         return "Q931UserBusy";
+      case Q931NoResponse:
+         return "Q931NoResponse";
+      case Q931NoAnswer:
+         return "Q931NoAnswer";
+      case Q931SubscriberAbsent:
+         return "Q931SubscriberAbsent";
+      case Q931CallRejected:
+         return "Q931CallRejected";
+      case Q931NumberChanged:
+         return "Q931NumberChanged";
+      case Q931Redirection:
+         return "Q931Redirection";
+      case Q931DestinationOutOfOrder:
+         return "Q931DestinationOutOfOrder";
+      case Q931InvalidNumberFormat:
+         return "Q931InvalidNumberFormat";
+      case Q931NormalUnspecified:
+         return "Q931NormalUnspecified";
+      case Q931StatusEnquiryResponse:
+         return "Q931StatusEnquiryResponse";
+      case Q931NoCircuitChannelAvailable:
+         return "Q931NoCircuitChannelAvailable";
+      case Q931NetworkOutOfOrder:
+         return "Q931NetworkOutOfOrder";
+      case Q931TemporaryFailure:
+         return "Q931TemporaryFailure";
+      case Q931Congestion:
+         return "Q931Congestion";
+      case Q931RequestedCircuitUnAvailable:
+         return "Q931RequestedCircuitUnavailable";
+      case Q931ResourcesUnavailable:
+         return "Q931ResourcesUnavailable";
+      case Q931IncompatibleDestination:
+         return "Q931IncompatibleDestination";
+      case Q931ProtocolErrorUnspecified:
+         return "Q931ProtocolErrorUnspecified";
+      case Q931RecoveryOnTimerExpiry:
+         return "Q931RecoveryOnTimerExpiry";
+      case Q931InvalidCallReference:
+         return "Q931InvaliedCallReference";
+      default:
+         return "Unsupported Cause Type";
+   }
+   return "Unsupported Cause Type";
+}
+
diff --git a/addons/ooh323c/src/ooq931.h b/addons/ooh323c/src/ooq931.h
new file mode 100644
index 000000000..a61ef8e6e
--- /dev/null
+++ b/addons/ooh323c/src/ooq931.h
@@ -0,0 +1,766 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+ * @file ooq931.h 
+ * This file contains functions to support call signalling. 
+ */
+
+#ifndef _OOQ931HDR_H_
+#define _OOQ931HDR_H_
+
+#include "ooasn1.h"
+#include "ootypes.h"
+#include "H323-MESSAGES.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+/** 
+ * @defgroup q931 Q.931/H.2250 Message Handling
+ * @{
+ */
+/* Maximum length of the Calling/Called party number number */
+#define OO_MAX_NUMBER_LENGTH 50
+
+/* Maximum value for a call token identifier */
+#define OO_MAX_CALL_TOKEN 9999
+
+/* Q.931 packet must be at least 5 bytes long */
+#define Q931_E_TOOSHORT         (-1001)  
+/* callReference field must be 2 bytes long */
+#define Q931_E_INVCALLREF       (-1002)  
+/* invalid length of message */
+#define Q931_E_INVLENGTH        (-1003)  
+
+enum Q931MsgTypes {
+   Q931NationalEscapeMsg  = 0x00,
+   Q931AlertingMsg        = 0x01,
+   Q931CallProceedingMsg  = 0x02,
+   Q931ConnectMsg         = 0x07,
+   Q931ConnectAckMsg      = 0x0f,
+   Q931ProgressMsg        = 0x03,
+   Q931SetupMsg           = 0x05,
+   Q931SetupAckMsg        = 0x0d,
+   Q931ResumeMsg          = 0x26,
+   Q931ResumeAckMsg       = 0x2e,
+   Q931ResumeRejectMsg    = 0x22,
+   Q931SuspendMsg         = 0x25,
+   Q931SuspendAckMsg      = 0x2d,
+   Q931SuspendRejectMsg   = 0x21,
+   Q931UserInformationMsg = 0x20,
+   Q931DisconnectMsg      = 0x45,
+   Q931ReleaseMsg         = 0x4d,
+   Q931ReleaseCompleteMsg = 0x5a,
+   Q931RestartMsg         = 0x46,
+   Q931RestartAckMsg      = 0x4e,
+   Q931SegmentMsg         = 0x60,
+   Q931CongestionCtrlMsg  = 0x79,
+   Q931InformationMsg     = 0x7b,
+   Q931NotifyMsg          = 0x6e,
+   Q931StatusMsg          = 0x7d,
+   Q931StatusEnquiryMsg   = 0x75,
+   Q931FacilityMsg        = 0x62
+};
+
+enum Q931IECodes {
+   Q931BearerCapabilityIE   = 0x04,
+   Q931CauseIE              = 0x08,
+   Q931FacilityIE           = 0x1c,
+   Q931ProgressIndicatorIE  = 0x1e,
+   Q931CallStateIE          = 0x14,
+   Q931DisplayIE            = 0x28,
+   Q931SignalIE             = 0x34,
+   Q931CallingPartyNumberIE = 0x6c,
+   Q931CalledPartyNumberIE  = 0x70,
+   Q931RedirectingNumberIE  = 0x74,
+   Q931UserUserIE           = 0x7e,
+   Q931KeypadIE             = 0x2c
+};
+
+enum Q931InformationTransferCapability {
+   Q931TransferSpeech,
+   Q931TransferUnrestrictedDigital = 8,
+   Q931TransferRestrictedDigital = 9,
+   Q931Transfer3_1kHzAudio = 16,
+   Q931TrasnferUnrestrictedDigitalWithTones = 17,
+   Q931TransferVideo = 24
+};
+
+enum Q931CauseValues {
+   Q931UnallocatedNumber           = 0x01,
+   Q931NoRouteToNetwork            = 0x02,
+   Q931NoRouteToDestination        = 0x03,
+   Q931ChannelUnacceptable         = 0x06,
+   Q931NormalCallClearing          = 0x10,
+   Q931UserBusy                    = 0x11,
+   Q931NoResponse                  = 0x12,
+   Q931NoAnswer                    = 0x13,
+   Q931SubscriberAbsent            = 0x14,
+   Q931CallRejected                = 0x15,
+   Q931NumberChanged               = 0x16,
+   Q931Redirection                 = 0x17,
+   Q931DestinationOutOfOrder       = 0x1b,
+   Q931InvalidNumberFormat         = 0x1c,
+   Q931NormalUnspecified           = 0x1f,
+   Q931StatusEnquiryResponse       = 0x1e,
+   Q931NoCircuitChannelAvailable   = 0x22,
+   Q931NetworkOutOfOrder           = 0x26,
+   Q931TemporaryFailure            = 0x29,
+   Q931Congestion                  = 0x2a,
+   Q931RequestedCircuitUnAvailable = 0x2c,
+   Q931ResourcesUnavailable        = 0x2f,
+   Q931IncompatibleDestination     = 0x58,
+   Q931ProtocolErrorUnspecified    = 0x6f,
+   Q931RecoveryOnTimerExpiry       = 0x66,
+   Q931InvalidCallReference        = 0x51,
+   Q931ErrorInCauseIE              = 0
+};
+
+enum Q931SignalInfo {
+   Q931SignalDialToneOn,
+   Q931SignalRingBackToneOn,
+   Q931SignalInterceptToneOn,
+   Q931SignalNetworkCongestionToneOn,
+   Q931SignalBusyToneOn,
+   Q931SignalConfirmToneOn,
+   Q931SignalAnswerToneOn,
+   Q931SignalCallWaitingTone,
+   Q931SignalOffhookWarningTone,
+   Q931SignalPreemptionToneOn,
+   Q931SignalTonesOff = 0x3f,
+   Q931SignalAlertingPattern0 = 0x40,
+   Q931SignalAlertingPattern1,
+   Q931SignalAlertingPattern2,
+   Q931SignalAlertingPattern3,
+   Q931SignalAlertingPattern4,
+   Q931SignalAlertingPattern5,
+   Q931SignalAlertingPattern6,
+   Q931SignalAlertingPattern7,
+   Q931SignalAlretingOff = 0x4f,
+   Q931SignalErrorInIE = 0x100
+};
+
+enum Q931NumberingPlanCodes {
+   Q931UnknownPlan          = 0x00,
+   Q931ISDNPlan             = 0x01,
+   Q931DataPlan             = 0x03,
+   Q931TelexPlan            = 0x04,
+   Q931NationalStandardPlan = 0x08,
+   Q931PrivatePlan          = 0x09,
+   Q931ReservedPlan         = 0x0f
+};
+
+enum Q931TypeOfNumberCodes {
+   Q931UnknownType          = 0x00,
+   Q931InternationalType    = 0x01,
+   Q931NationalType         = 0x02,
+   Q931NetworkSpecificType  = 0x03,
+   Q931SubscriberType       = 0x04,
+   Q931AbbreviatedType      = 0x06,
+   Q931ReservedType         = 0x07
+};
+
+enum Q931CodingStandard{
+  Q931CCITTStd = 0,
+  Q931ReservedInternationalStd,
+  Q931NationalStd,
+  Q931NetworkStd
+};
+
+enum Q931TransferMode {
+  Q931TransferCircuitMode = 0,   /* 00 */
+  Q931TransferPacketMode  = 2   /* 10 */
+};
+
+enum Q931TransferRate{
+  Q931TransferRatePacketMode = 0x00,  /* 00000 */
+  Q931TransferRate64Kbps     = 0x10,  /* 10000 */
+  Q931TransferRate128kbps    = 0x11,  /* 10001 */
+  Q931TransferRate384kbps    = 0x13,  /* 10011 */
+  Q931TransferRate1536kbps   = 0x15,  /* 10101 */
+  Q931TransferRate1920kbps   = 0x17   /* 10111 */
+};
+
+enum Q931UserInfoLayer1Protocol{
+  Q931UserInfoLayer1CCITTStdRate = 1,
+  Q931UserInfoLayer1G711ULaw,
+  Q931UserInfoLayer1G711ALaw,
+  Q931UserInfoLayer1G721ADPCM,
+  Q931UserInfoLayer1G722G725,
+  Q931UserInfoLayer1H261,
+  Q931UserInfoLayer1NonCCITTStdRate,
+  Q931UserInfoLayer1CCITTStdRateV120,
+  Q931UserInfoLayer1X31
+};
+
+/*
+  Structure to build store outgoing encoded UUIE
+  The different fields in the structure have octet lengths 
+  as specified in the spec. 
+*/
+typedef struct Q931InformationElement {
+   int discriminator;
+   int offset;
+   int length;
+   ASN1OCTET data[1];
+} Q931InformationElement;
+
+/**
+ * Q.931 message structure. Contains context for memory allocation, 
+ * protocol discriminator, call reference, meesage type and list of 
+ * user-user information elements (IEs).
+ */
+typedef struct Q931Message {
+   ASN1UINT protocolDiscriminator;
+   ASN1UINT callReference;
+   ASN1BOOL fromDestination;
+   ASN1UINT messageType;      /* Q931MsgTypes */
+   ASN1UINT tunneledMsgType;  /* The H245 message this message is tunneling*/
+   ASN1INT  logicalChannelNo; /* channel number associated with tunneled */
+                              /* message, 0 if no channel */
+   DList ies;    
+   Q931InformationElement *bearerCapabilityIE;
+   Q931InformationElement *callingPartyNumberIE;
+   Q931InformationElement *calledPartyNumberIE;
+   Q931InformationElement *causeIE;
+   Q931InformationElement *keypadIE;
+   H225H323_UserInformation *userInfo;
+} Q931Message;
+
+/**
+ * This structure is used to hold an H.323 alias address.
+ */
+typedef struct OOAliases {
+   int type;           /*!< H.225 AliasAddress choice option (t value) */
+   char *value;        /*!< H.225 AliasAddress value */
+   OOBOOL registered;
+   struct OOAliases *next;
+} OOAliases;
+
+#define ooAliases OOAliases
+
+struct OOH323CallData;
+
+/*
+ * These are message callbacks which can be used by user applications
+ * to perform application specific things on receiving a particular 
+ * message or before sending a particular message. For ex. user application
+ * can change values of some parameters of setup message before it is actually
+ * sent out.
+ */
+/**
+ * This callback is triggered when an H.225 SETUP message is received by 
+ * the application.
+ * @param call  The call the message is associated with.
+ * @param pmsg  Q.931 message structure.
+ * @return OO_OK if message processing successful or OO_FAILED if not.
+ */
+typedef int (*cb_OnReceivedSetup)
+   (struct OOH323CallData *call, struct Q931Message *pmsg);
+
+/**
+ * This callback is triggered when an H.225 CONNECT message is received by 
+ * the application.
+ * @param call  The call the message is associated with.
+ * @param pmsg  Q.931 message structure.
+ * @return OO_OK if message processing successful or OO_FAILED if not.
+ */
+typedef int (*cb_OnReceivedConnect)
+   (struct OOH323CallData *call, struct Q931Message *pmsg);
+
+/**
+ * This callback is triggered after an H.225 SETUP message has been 
+ * constructed and is ready to be sent out.  It provides the application 
+ * with an opportunity to add additional non-standard information.
+ * @param call  The call the message is associated with.
+ * @param pmsg  Q.931 message structure.
+ * @return OO_OK if message processing successful or OO_FAILED if not.
+ */
+typedef int (*cb_OnBuiltSetup)
+   (struct OOH323CallData *call, struct Q931Message *pmsg);
+
+/**
+ * This callback is triggered after an H.225 CONNECT message has been 
+ * constructed and is ready to be sent out.  It provides the application 
+ * with an opportunity to add additional non-standard information.
+ * @param call  The call the message is associated with.
+ * @param pmsg  Q.931 message structure.
+ * @return OO_OK if message processing successful or OO_FAILED if not.
+ */
+typedef int (*cb_OnBuiltConnect)
+   (struct OOH323CallData *call, struct Q931Message *pmsg);
+
+/**
+ * This structure holds the various callback functions that are 
+ * triggered when H.225 messages are received or constructed.
+ * @see ooH323EpSetH225MsgCallbacks
+ */
+typedef struct OOH225MsgCallbacks {
+   cb_OnReceivedSetup onReceivedSetup;
+   cb_OnReceivedConnect onReceivedConnect;
+   cb_OnBuiltSetup onBuiltSetup;
+   cb_OnBuiltConnect onBuiltConnect;
+} OOH225MsgCallbacks;
+
+/**
+ * This function is invoked to decode a Q931 message. 
+ * 
+ * @param call     Handle to call which owns the message.
+ * @param msg      Pointer to the Q931 message
+ * @param length   Length of the encoded data
+ * @param data     Pointer to the data to be decoded
+ *
+ * @return         Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooQ931Decode 
+(struct OOH323CallData *call, Q931Message* msg, int length, ASN1OCTET *data);
+
+/**
+ * This function is used to decode the UUIE of the message from the list of
+ * ies. It decodes the User-User ie and populates the userInfo field of the
+ * message.
+ * @param q931Msg    Pointer to the message whose User-User ie has to be 
+ *                   decoded.    
+ *
+ * @return           OO_OK, on success. OO_FAILED, on failure.
+ */ 
+EXTERN int ooDecodeUUIE(Q931Message *q931Msg);
+
+/**
+ * This function is used to encode the UUIE field of the Q931 message.
+ * It encodes UUIE and adds the encoded data to the list of ies.
+ * @param q931msg        Pointer to the Q931 message whose UUIE field has to be
+ *                       encoded.
+ *
+ * @return               OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooEncodeUUIE(Q931Message *q931msg);
+
+/**
+ * This function is invoked to retrieve an IE element from a Q931 message. 
+ * 
+ * @param q931msg  Pointer to the Q931 message
+ * @param ieCode   IE code for the IE element to be retrieved
+ *
+ * @return         Pointer to a Q931InformationElement contating 
+ *                 the IE element.
+ */
+EXTERN Q931InformationElement* ooQ931GetIE (const Q931Message* q931msg, 
+                                            int ieCode);
+
+/**
+ * This function is invoked to print a Q931 message. 
+ * 
+ * @param q931msg  Pointer to the Q931 message
+ *
+ * @return         - none
+ */
+EXTERN void ooQ931Print (const Q931Message* q931msg);
+
+
+/**
+ * This function is invoked to create an outgoing Q931 message. 
+ * 
+ * @param msg      Reference to the pointer of type Q931 message.
+ * @param msgType  Type of Q931 message to be created
+ *
+ * @return         Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooCreateQ931Message(Q931Message **msg, int msgType);
+
+/**
+ * This function is invoked to generate a unique call reference number. 
+ *
+ * @return         - call reference number
+ */
+EXTERN ASN1USINT ooGenerateCallReference(void);
+
+
+/**
+ * This function is used to generate a unique call identifier for the call.
+ * @param callid      Pointer to the callid structure, which will be populated
+ *                    with the generated callid.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooGenerateCallIdentifier(H225CallIdentifier *callid);
+
+/**
+ * This function is invoked to release the memory used up by a Q931 message 
+ * 
+ * @param q931Msg  Pointer to a Q931 message which has to be freed.
+ *
+ * @return         Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooFreeQ931Message(Q931Message *q931Msg);
+
+/**
+ * This function is invoked to retrive the outgoing message buffer for 
+ * Q931 message
+ *
+ * @param call     Pointer to call for which outgoing Q931 message has to be 
+ *                 retrieved.
+ * @param msgbuf   Pointer to a buffer in which retrieved message will
+ *                 be returned.
+ * @param len      Pointer to int in which length of the buffer will
+ *                 be returned.
+ * @param msgType  Pointer to integer in which message type of the ougoing
+ *                 message is returned.
+ *
+ * @return         Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooGetOutgoingQ931Msgbuf
+(struct OOH323CallData *call, ASN1OCTET * msgbuf, int* len, int *msgType);
+
+/**
+ * This function is invoked to send a ReleaseComplete message for 
+ * the currently active call.
+ *
+ * @param call    Pointer to the call for which ReleaseComplete message have 
+ *                to be sent.  
+ *
+ * @return         Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooSendReleaseComplete(struct OOH323CallData *call);
+
+/**
+ * This function is invoked to send a call proceeding message in response to
+ * received setup message.
+ *
+ * @param call    Pointer to the call for which CallProceeding message have to
+ *                be sent.  
+ *
+ * @return        Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooSendCallProceeding(struct OOH323CallData *call);
+
+/**
+ * This function is invoked to send alerting message in response to received  
+ * setup message. 
+ *
+ * @param call     Pointer to the call for which Alerting message have to be 
+ *                 sent.  
+ *
+ * @return         Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooSendAlerting(struct OOH323CallData *call);
+
+/**
+ * This function is invoked to send Facility message.
+ *
+ * @param call     Pointer to the call for which Facility message have to be 
+ *                 sent.  
+ *
+ * @return         Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooSendFacility(struct OOH323CallData *call);
+
+
+/**
+ * This function is used to send dtmf data as Q931 keypad information element
+ * as part of information message.
+ * @param call     Pointer to the call for dtmf data has to be sent.
+ * @param data     Dtmf data to be sent.
+ *
+ * @return         OO_OK, on success; OO_FAILED, on failure.
+ */
+EXTERN int ooQ931SendDTMFAsKeyPadIE
+          (struct OOH323CallData *call, const char* data);
+
+/**
+ * This function is invoked to send a Connect message in response to received  
+ * setup message. 
+ *
+ * @param call      Pointer to the call for which connect message has to be 
+ *                  sent.  
+ *
+ * @return          Completion status - 0 on success, -1 on failure
+ */
+EXTERN int ooSendConnect(struct OOH323CallData *call);
+
+/**
+ * This function is used to send a SETUP message for outgoing call. It first
+ * creates an H.225 TCP connection with the remote end point and then sends 
+ * SETUP message over this connection.
+ * @param dest      Destination - IP:Port/alias.
+ * @param callToken Unique token for the new call.
+ * @param opts      Call specific options. If passed a non-null value, these
+ *                  options will override global endpoint settings.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure
+ */
+EXTERN int ooH323MakeCall(char *dest, char *callToken, ooCallOptions *opts);
+
+/**
+ * Helper function used to make a call once it is approved by the Gk.
+ * In case of no gk, this function is directly called to make a call.
+ * @param call        Handle to the new call.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure
+ */
+int ooH323CallAdmitted( struct OOH323CallData *call);
+
+/**
+ * This function is used to handle a call forward request sent to local
+ * endpoint by remote endpoint.
+ * @param call        Handle to the call which is being forwarded
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323HandleCallFwdRequest(struct OOH323CallData *call);
+
+/**
+ * This function is used for forwarding/redirecting a call to third party.
+ * @param callToken   callToken for the call which has to be redirected.
+ * @param dest        Address to which call has to be forwarded. Can be 
+ *                    IP:Port or alias.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323ForwardCall(char* callToken, char *dest);
+
+/**
+ * This function is used to hangup a currently active call. It sets the call
+ * state to CLEARING and initiates closing of all logical channels.
+ * @param callToken Unique token of the call to be hanged.
+ * @param reason    Reason for ending call.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323HangCall(char * callToken, OOCallClearReason reason);
+
+
+/** 
+ * Function to accept a call by sending connect. This function is used
+ * as a helper function to ooSendConnect.
+ * @param call      Pointer to the call for which connect has to be sent
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooAcceptCall(struct OOH323CallData *call);
+
+/*
+ * An helper function to ooMakeCall.
+ * @param call      Pointer to the new call.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooH323MakeCall_helper(struct OOH323CallData *call);
+
+/**
+ * This function is used to parse the destination
+ * @param call      Handle to related call.
+ * @param dest      Destination string to be parsed.
+ * @param parsedIP  Pointer to buffer in which parsed ip:port will be returned.
+ * @param len       Length of the buffer passed.
+ * @param aliasList Aliase List in which new aliases will be added.
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooParseDestination
+   (struct OOH323CallData *call, char *dest, char *parsedIP, unsigned len,
+    OOAliases** aliasList);
+
+/**
+ * This function is used to generate a new call token
+ * @param callToken Handle to the buffer in which new call token will be
+ *                  returned
+ * @param size      size of the buffer
+ *
+ * @return          OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooGenerateCallToken (char *callToken, size_t size);
+
+
+/**
+ * This function sends an encoded H.245 message buffer as a tunneled 
+ * H.245 Facility message.
+ * @param call             Pointer to the call for which H.245 message has to
+ *                         be tunneled.
+ * @param msgbuf           Pointer to the encoded H.245 message to be tunneled.
+ *
+ * @param h245Len          Length of the encoded H.245 message buffer.
+ * @param h245MsgType      Type of the H245 message
+ * @param associatedChan   The logical channel number with which the tunneled
+ *                         message is associated. In case of no channel, this
+ *                         value should be 0.
+ *
+ * @return                 OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooSendAsTunneledMessage
+(struct OOH323CallData *call, ASN1OCTET* msgbuf, 
+ int h245Len, int h245MsgType, int associatedChan); 
+ 
+
+/**
+ * This function is used to encode an H.225 message.
+ * @param call            Handle to the call.
+ * @param pq931Msg        Pointer to the message to be encoded.
+ * @param msgbuf          Pointer to the buffer in which encoded message will 
+ *                        be returned.
+ * @param size            Size of the buffer passed.
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooEncodeH225Message(struct OOH323CallData *call, Q931Message *pq931Msg, 
+                        char *msgbuf, int size);
+
+/**
+ * This is a callback function which is called when there is no CONNECT 
+ * response from the remote endpoint after the SETUP has been sent and timeout
+ * period has passed.
+ * @param data            The callback data registered at the time of timer 
+ *                        creation.
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure.
+ */
+int ooCallEstbTimerExpired(void *data);
+
+
+
+/**
+ * This function is used to add a keypad IE to a Q931 message for sending dtmf.
+ * @param pmsg            Q931 message to which keypad ie has to be
+ *                        added.
+ * @param data            DTMF data to be sent.
+ *
+ * @return                OO_OK on success, OO_FAILED, on failure.
+ */
+EXTERN int ooQ931SetKeypadIE(Q931Message *pmsg, const char* data);
+
+/**
+ * This function is used to add a bearer capability IE to a Q931 message.
+ * @param pmsg            Q931 message to which bearer capability ie has to be
+ *                        added.
+ * @param codingStandard  Coding standard to be used.
+ * @param capability      Information transfer capability
+ * @param transferMode    Information transfer mode.(circuit/packet modes).
+ * @param transferRate    Information transfer rate.
+ * @param userInfoLayer1  User information layer 1 protocol.
+ *
+ * @return                OO_OK on success, OO_FAILED, on failure.
+ */
+EXTERN int ooSetBearerCapabilityIE
+   (Q931Message *pmsg, enum Q931CodingStandard codingStandard, 
+    enum Q931InformationTransferCapability capability, 
+    enum Q931TransferMode transferMode, enum Q931TransferRate transferRate,
+    enum Q931UserInfoLayer1Protocol userInfoLayer1);
+
+/**
+ * This function is used to add a called party number ie to a q931 message.
+ * @param pmsg            Q931 message to which CalledPartyNumber IE has to be
+ *                        added.
+ * @param number          Number for called party.
+ * @param plan            Numbering Plan used
+ * @param type            Type of number
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooQ931SetCalledPartyNumberIE
+   (Q931Message *pmsg, const char *number, unsigned plan, unsigned type);
+
+
+/**
+ * This function is used to add a CallingPartyNumber ie to a q931 message.
+ * @param pmsg            Q931 message to which CallingPartyNumber IE has to be
+ *                        added.
+ * @param number          Number for calling party.
+ * @param plan            Numbering Plan used
+ * @param type            Type of number
+ * @param presentation    Presentation of the address is allowed or restricted.
+ * @param screening       Whether address was provided by endpoint or screened
+ *                        by gatekeeper.
+ *
+ * @return                OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooQ931SetCallingPartyNumberIE
+   (Q931Message *pmsg, const char *number, unsigned plan, unsigned type, 
+    unsigned presentation, unsigned screening);
+
+/** 
+ * This function is used to set a cause ie for a q931 message.
+ * @param pmsg        Valid Q931 Message
+ * @param cause       Q931 Cause Value
+ * @param coding      coding standard used. 0 for ITU-T standard coding
+ * @param location    location. 0 for user.
+ *
+ * @return            OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooQ931SetCauseIE
+   (Q931Message *pmsg,enum Q931CauseValues cause, unsigned coding, 
+    unsigned location);
+
+/**
+ * This function is used to convert a call clear reason to cause and 
+ * reason code. It is used when local user is endoing the call and 
+ * sending releaseComplete.
+ * @param clearReason   Reason for ending call.
+ * @param cause         Pointer to Q931CauseVaules enum in which cause
+ *                      will be returned.
+ * @param reasonCode    Pointer to unsigned int in which reasonCode will
+ *                      be returned.
+ *
+ * @return              OO_OK, on success. OO_FAILED, on failure.
+ */
+EXTERN int ooQ931GetCauseAndReasonCodeFromCallClearReason
+   (OOCallClearReason clearReason, enum Q931CauseValues *cause, 
+    unsigned *reasonCode);
+
+/**
+ * This function is used to convert a cause value and reason code received
+ * in ReleaseComplete message from remote endpoint into a CallClearReason.
+ * @param cause         cause value received.
+ * @param reasonCode    reasonCode received.
+ *
+ * @return              Returns a CallClearReason.
+ */
+EXTERN OOCallClearReason ooGetCallClearReasonFromCauseAndReasonCode
+   (enum Q931CauseValues cause, unsigned reasonCode);
+
+/**
+ * This function is used to retrieve the description text for a 
+ * message type.
+ *
+ * @param msgType  Message type.
+ * @return         The text description string.
+ */
+EXTERN const char* ooGetMsgTypeText (int msgType);
+
+/**
+ * This function is used to retrieve the text description for a Q931 Cause
+ * value in Cause IE.
+ * @param val     Q931 Cause value
+ * @return        The text description string
+ */
+EXTERN const char* ooGetQ931CauseValueText (int val);
+
+/** 
+ * @} 
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __Q931HDR_H */
diff --git a/addons/ooh323c/src/ootrace.c b/addons/ooh323c/src/ootrace.c
new file mode 100644
index 000000000..0fd5a68ed
--- /dev/null
+++ b/addons/ooh323c/src/ootrace.c
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "ootypes.h"
+#include "ootrace.h"
+#include "ooCommon.h"
+#include "ooCapability.h"
+#include "ooq931.h"
+#include "ooh245.h"
+#include "ooh323ep.h"
+
+/** Global endpoint structure */
+extern OOH323EndPoint gH323ep;
+
+static OOUINT32 gs_traceLevel = TRACELVL;
+
+void ooSetTraceThreshold(OOUINT32 traceLevel)
+{
+   gs_traceLevel = traceLevel;
+}
+
+void ooTrace(OOUINT32 traceLevel, const char * fmtspec, ...)
+{
+   va_list arglist;
+   char logMessage[MAXLOGMSGLEN];
+   if(traceLevel > gs_traceLevel) return;
+   va_start (arglist, fmtspec);
+   /*   memset(logMessage, 0, MAXLOGMSGLEN);*/
+   vsprintf(logMessage, fmtspec, arglist);   
+   va_end(arglist);
+   ooTraceLogMessage(logMessage);
+}
+
+void ooTraceLogMessage(const char * logMessage)
+{
+   char timeString[100];
+   char currtime[3];
+   static int lasttime=25;
+   int printDate =0;
+   static int printTime=1;
+   
+#ifdef _WIN32
+   
+   SYSTEMTIME systemTime;
+   GetLocalTime(&systemTime);
+   GetTimeFormat(LOCALE_SYSTEM_DEFAULT,0, &systemTime, "HH':'mm':'ss", 
+                                                              timeString, 100);
+   GetTimeFormat(LOCALE_SYSTEM_DEFAULT,0, &systemTime, "H", currtime, 3);
+   if(lasttime> atoi(currtime))
+      printDate=1;
+   lasttime = atoi(currtime);
+   
+#else
+   struct tm *ptime;
+   char dateString[15];
+   time_t t = time(NULL);
+   ptime = localtime(&t);
+   strftime(timeString, 100, "%H:%M:%S", ptime);
+   strftime(currtime, 3, "%H", ptime);
+   if(lasttime>atoi(currtime))
+       printDate = 1;
+   lasttime = atoi(currtime);   
+#endif
+
+      
+#ifdef _WIN32
+   if(printDate)
+   {
+      printDate = 0;
+      fprintf(gH323ep.fptraceFile, "---------Date %d/%d/%d---------\n",
+                      systemTime.wMonth, systemTime.wDay, systemTime.wYear);
+   }
+   if(printTime) {
+      fprintf(gH323ep.fptraceFile, "%s:%03d  %s", timeString, 
+              systemTime.wMilliseconds, logMessage);
+   }
+   else
+      fprintf(gH323ep.fptraceFile, "%s", logMessage);
+   
+   fflush(gH323ep.fptraceFile);
+#else
+   if(printDate)
+   {
+      printDate = 0;
+      strftime(dateString, 15, "%m/%d/%Y", ptime);
+      fprintf(gH323ep.fptraceFile, "---------Date %s---------\n", 
+              dateString);
+   }
+   if(printTime) {
+      struct timeval systemTime;
+      gettimeofday(&systemTime, NULL);
+      fprintf(gH323ep.fptraceFile, "%s:%03ld  %s", timeString, 
+               systemTime.tv_usec/1000, logMessage);
+   }
+   else
+      fprintf(gH323ep.fptraceFile, "%s", logMessage);
+
+   fflush(gH323ep.fptraceFile);
+#endif
+   
+   if(strchr(logMessage, '\n'))
+      printTime = 1;
+   else
+      printTime = 0;
+
+}
+
+int ooLogAsn1Error(int stat, const char * fname, int lno)
+{
+   OOTRACEERR4("Asn1Error: %d at %s:%d\n", stat, fname, lno);
+   return stat;
+}
+
diff --git a/addons/ooh323c/src/ootrace.h b/addons/ooh323c/src/ootrace.h
new file mode 100644
index 000000000..9678c8979
--- /dev/null
+++ b/addons/ooh323c/src/ootrace.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/**
+ * @file ootrace.h 
+ * This file defines the trace functionality
+ */
+#include "ooCommon.h"
+#ifndef _OOTRACE_H_
+#define _OOTRACE_H_
+
+
+/* tracing */
+#define OOTRCLVLERR  1
+#define OOTRCLVLWARN 2
+#define OOTRCLVLINFO 3
+#define OOTRCLVLDBGA 4
+#define OOTRCLVLDBGB 5
+#define OOTRCLVLDBGC 6
+
+#ifdef _OOWARNING
+#define TRACELVL OOTRCLVLWARN
+#endif
+#ifdef _OOINFO
+#define TRACELVL OOTRCLVLINFO
+#endif
+#ifdef _OODEBUGA
+#define TRACELVL OOTRCLVLDBGA
+#endif
+#ifdef _OODEBUGB
+#define TRACELVL OOTRCLVLDBGB
+#endif
+#ifdef _OODEBUGC
+#define TRACELVL OOTRCLVLDBGC
+#endif
+
+/* Ensure we always log error messages */
+#ifndef TRACELVL
+#define TRACELVL 1
+#endif
+
+#define OOTRACEERR1(a)        ooTrace(OOTRCLVLERR,"%s", a)
+#define OOTRACEERR2(a,b)      ooTrace(OOTRCLVLERR,a,b)
+#define OOTRACEERR3(a,b,c)    ooTrace(OOTRCLVLERR,a,b,c)
+#define OOTRACEERR4(a,b,c,d)  ooTrace(OOTRCLVLERR,a,b,c,d)
+#define OOTRACEWARN1(a)       ooTrace(OOTRCLVLWARN,a)
+#define OOTRACEWARN2(a,b)     ooTrace(OOTRCLVLWARN,a,b)
+#define OOTRACEWARN3(a,b,c)   ooTrace(OOTRCLVLWARN,a,b,c)
+#define OOTRACEWARN4(a,b,c,d) ooTrace(OOTRCLVLWARN,a,b,c,d)
+#define OOTRACEINFO1(a)       ooTrace(OOTRCLVLINFO, a)
+#define OOTRACEINFO2(a,b)     ooTrace(OOTRCLVLINFO,a,b)
+#define OOTRACEINFO3(a,b,c)   ooTrace(OOTRCLVLINFO,a,b,c)
+#define OOTRACEINFO4(a,b,c,d) ooTrace(OOTRCLVLINFO,a,b,c,d)
+#define OOTRACEINFO5(a,b,c,d,e) ooTrace(OOTRCLVLINFO,a,b,c,d,e)
+#define OOTRACEINFO6(a,b,c,d,e,f) ooTrace(OOTRCLVLINFO,a,b,c,d,e, f)
+#ifndef _COMPACT 
+#define OOTRACEDBGA1(a)       ooTrace(OOTRCLVLDBGA,a)
+#define OOTRACEDBGA2(a,b)     ooTrace(OOTRCLVLDBGA,a,b)
+#define OOTRACEDBGA3(a,b,c)   ooTrace(OOTRCLVLDBGA,a,b,c)
+#define OOTRACEDBGA4(a,b,c,d) ooTrace(OOTRCLVLDBGA,a,b,c,d)
+#define OOTRACEDBGA5(a,b,c,d,e) ooTrace(OOTRCLVLDBGA,a,b,c,d,e)
+#define OOTRACEDBGB1(a)       ooTrace(OOTRCLVLDBGB,"%s",a)
+#define OOTRACEDBGB2(a,b)     ooTrace(OOTRCLVLDBGB,a,b)
+#define OOTRACEDBGB3(a,b,c)   ooTrace(OOTRCLVLDBGB,a,b,c)
+#define OOTRACEDBGB4(a,b,c,d) ooTrace(OOTRCLVLDBGB,a,b,c,d)
+#define OOTRACEDBGC1(a)       ooTrace(OOTRCLVLDBGC,a)
+#define OOTRACEDBGC2(a,b)     ooTrace(OOTRCLVLDBGC,a,b)
+#define OOTRACEDBGC3(a,b,c)   ooTrace(OOTRCLVLDBGC,a,b,c)
+#define OOTRACEDBGC4(a,b,c,d) ooTrace(OOTRCLVLDBGC,a,b,c,d)
+#define OOTRACEDBGC5(a,b,c,d,e) ooTrace(OOTRCLVLDBGC,a,b,c,d,e)
+#else
+#define OOTRACEDBGA1(a) 
+#define OOTRACEDBGA2(a,b)
+#define OOTRACEDBGA3(a,b,c)
+#define OOTRACEDBGA4(a,b,c,d)
+#define OOTRACEDBGA5(a,b,c,d,e)
+#define OOTRACEDBGB1(a)
+#define OOTRACEDBGB2(a,b) 
+#define OOTRACEDBGB3(a,b,c)
+#define OOTRACEDBGB4(a,b,c,d)
+#define OOTRACEDBGC1(a)
+#define OOTRACEDBGC2(a,b)
+#define OOTRACEDBGC3(a,b,c)
+#define OOTRACEDBGC4(a,b,c,d)
+#define OOTRACEDBGC5(a,b,c,d,e)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+/**
+ * This function is used to set the trace level.
+ * @param traceLevel  New trace level. Various values are: OOTRCLVLERR, 
+ *                    OOTRCLVLWARN, OOTRCLVLINFO, OOTRCLVLDBGA, OOTRCLVLDBGB,
+ *                    OOTRCLVLDBGC
+ *
+ * @return            None 
+ */
+EXTERN void ooSetTraceThreshold(OOUINT32 traceLevel);
+
+/**
+ * This function is used to write the messages to the trace file.
+ *
+ * @param traceLevel  Trace level for the message.
+ * @param fmtspec     Printf style format spec.
+ * @param ...         Printf style variable list of arguments              
+ *
+ * @return            - none
+ */
+EXTERN void ooTrace(OOUINT32 traceLevel, const char * fmtspec, ...)__attribute__((format(printf, 2, 3)));
+
+/**
+ * Helper function for the trace function. This function performs actual
+ * writing to file.
+ * @param logMessage  Log message to be writted to file.
+ *
+ * @return            - none
+ */
+void ooTraceLogMessage(const char * logMessage);
+
+/**
+ *
+ */
+void ooChangeIPToNWOrder(char * internetIP, char* networkIP);
+
+int ooLogAsn1Error(int stat, const char * fname, int lno);
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/addons/ooh323c/src/ootypes.h b/addons/ooh323c/src/ootypes.h
new file mode 100644
index 000000000..51b97e41c
--- /dev/null
+++ b/addons/ooh323c/src/ootypes.h
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/*! \mainpage 
+ * <H1>ooH323c Stack Functions</H1>
+ *
+ * The <B>Objective Open H.323 for C (ooH323c)</B> protocol stack is an 
+ * open source applications program interface (API) for building H.323 based 
+ * applications.   The stack implements Q.931/H.225 call signaling procedures, 
+ * H.245 logical channel operations, and Registration, Admission, and Status 
+ * (RAS) messaging for Gatekeeper communications.
+ *
+ * The categories of user functions provided are as follows:
+ * <UL>
+ * <LI>Stack command functions.  These are high level functions used to 
+ * initiate common H.323 telephony operations (for example, to make a 
+ * call).</LI>
+ * <LI>Gatekeeper functions.  These are high level functions for 
+ * managing communications with a gatekeeper using RAS messages.</LI>
+ * <LI>H.323 endpoint management functions.  These are function for 
+ * used for managing the global H.323 endpoint.</LI>
+ * <LI>Call management functions.  These are functions used to manage 
+ * active calls within the stack.</LI>
+ * <LI>Capability management functions.  These functions are used for 
+ * negotiating capabilities between two different terminals.</LI>
+ * <LI>H.225 and H.245 message handling functions.  Functions for 
+ * creating and handling H.323 standard ASN.1 messages.</LI>
+ * <LI>Q.931 functions.  Functions for the execution of various 
+ * standard Q.931 operations.</LI>
+ * <LI>TCP/IP and UDP socket communication functions.  Low-level 
+ * functions for writing data to and receiving data from sockets.</LI>
+ * </UL>
+ */ 
+/**
+ * @file ootypes.h 
+ * This file contains definitions of common constants and data structures.
+ */
+#ifndef _OOTYPES_H_
+#define _OOTYPES_H_
+
+#include "ooSocket.h"
+#include "MULTIMEDIA-SYSTEM-CONTROL.h"
+#include "H323-MESSAGES.h"
+#include "ooasn1.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+
+#define OOH323C_VERSION "v0.8.3"
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+
+/** 
+ * @defgroup ootypes Common type and constant definitions.
+ * @{
+ */
+/* Function return codes */
+#define OO_FAILED       -1
+#define OO_OK           0
+
+/* TODO: States for both local and remote initiation should be maintained
+   separately */
+/**
+ * States defined for master/slave determination procedure.
+ */
+typedef enum OOMasterSlaveState {
+   OO_MasterSlave_Idle,
+   OO_MasterSlave_DetermineSent, 
+   OO_MasterSlave_AckReceived,
+   OO_MasterSlave_Master,
+   OO_MasterSlave_Slave
+} OOMasterSlaveState;
+
+/** 
+ * States defined for the capability exchange procedure. 
+ */
+typedef enum {
+   OO_LocalTermCapExchange_Idle, 
+   OO_LocalTermCapSetSent, 
+   OO_LocalTermCapSetAckRecvd, 
+   OO_RemoteTermCapExchange_Idle, 
+   OO_RemoteTermCapSetRecvd, 
+   OO_RemoteTermCapSetAckSent
+} OOCapExchangeState;
+
+/** 
+ * Call clear reason codes.
+ */
+typedef enum OOCallClearReason {
+   OO_REASON_UNKNOWN=0, 
+   OO_REASON_INVALIDMESSAGE,
+   OO_REASON_TRANSPORTFAILURE, 
+   OO_REASON_NOROUTE,
+   OO_REASON_NOUSER,
+   OO_REASON_NOBW,
+   OO_REASON_GK_NOCALLEDUSER,
+   OO_REASON_GK_NOCALLERUSER,
+   OO_REASON_GK_NORESOURCES,
+   OO_REASON_GK_UNREACHABLE,
+   OO_REASON_GK_CLEARED,
+   OO_REASON_NOCOMMON_CAPABILITIES,
+   OO_REASON_REMOTE_FWDED,   
+   OO_REASON_LOCAL_FWDED,
+   OO_REASON_REMOTE_CLEARED, 
+   OO_REASON_LOCAL_CLEARED, 
+   OO_REASON_REMOTE_BUSY,
+   OO_REASON_LOCAL_BUSY,
+   OO_REASON_REMOTE_NOANSWER,
+   OO_REASON_LOCAL_NOTANSWERED,
+   OO_REASON_REMOTE_REJECTED,
+   OO_REASON_LOCAL_REJECTED,
+   OO_REASON_REMOTE_CONGESTED,
+   OO_REASON_LOCAL_CONGESTED
+} OOCallClearReason;
+
+/** Terminal type of the endpoint. Default is 60. */
+#define OOTERMTYPE 60
+
+/** Maximum length of an IP address (xxx.xxx.xxx.xxx). */
+#define MAX_IP_LENGTH 15
+
+/** Maximum length of a log file message */
+#define MAXLOGMSGLEN 2048
+
+/** Number of times to retry a failed operation. */
+#define DEFAULT_MAX_RETRIES 3
+
+/**
+   Various message types for H225 and H245 messages
+*/
+#define OO_MSGTYPE_MIN                     101
+#define OOQ931MSG                          101
+#define OOH245MSG                          102
+#define OOSetup                            103
+#define OOCallProceeding                   104
+#define OOAlert                            105
+#define OOConnect                          106
+#define OOReleaseComplete                  107
+#define OOFacility                         108
+#define OOInformationMessage               109
+#define OOMasterSlaveDetermination         110
+#define OOMasterSlaveAck                   111
+#define OOMasterSlaveReject                112
+#define OOMasterSlaveRelease               113
+#define OOTerminalCapabilitySet            114
+#define OOTerminalCapabilitySetAck         115
+#define OOTerminalCapabilitySetReject      116
+#define OOTerminalCapabilitySetRelease     117
+#define OOOpenLogicalChannel               118
+#define OOOpenLogicalChannelAck            119
+#define OOOpenLogicalChannelReject         120
+#define OOOpenLogicalChannelRelease        121
+#define OOOpenLogicalChannelConfirm        122
+#define OOCloseLogicalChannel              123
+#define OOCloseLogicalChannelAck           124
+#define OORequestChannelClose              125
+#define OORequestChannelCloseAck           126
+#define OORequestChannelCloseReject        127
+#define OORequestChannelCloseRelease       128
+#define OOEndSessionCommand                129
+#define OOUserInputIndication              130
+
+#define OO_MSGTYPE_MAX                     130
+
+/* Timer types */
+#define OO_CALLESTB_TIMER  (1<<0)
+#define OO_MSD_TIMER       (1<<1)
+#define OO_TCS_TIMER       (1<<2)
+#define OO_OLC_TIMER       (1<<3)
+#define OO_CLC_TIMER       (1<<4)
+#define OO_RCC_TIMER       (1<<5)
+#define OO_SESSION_TIMER   (1<<6)
+#define OO_H245CONNECT_TIMER (1<<7)
+
+/** Maximum length for received messages */
+#define MAXMSGLEN 4096
+
+/** Maximum length of a filename */
+#define MAXFILENAME 256
+
+/**
+ * Endpoint call modes. The call mode of the endpoint dictates what type
+ * of channels are created for the calls placed by the endpoint or received
+ * by the endpoint.
+ */
+typedef enum OOCallMode {
+   OO_CALLMODE_AUDIOCALL,   /*!< Audio call */
+   OO_CALLMODE_AUDIORX,     /*!< Audio call - receive only */
+   OO_CALLMODE_AUDIOTX,     /*!< Audio call - transmit only */
+   OO_CALLMODE_VIDEOCALL,   /*!< Video call */
+   OO_CALLMODE_FAX          /*!< Fax transmission */
+} OOCallMode;
+
+/*
+ * Flag macros - these operate on bit mask flags using mask values
+ */
+/** This macro sets a flag within a bit mask */
+#define OO_SETFLAG(flags,mask) (flags |= (ASN1UINT)mask)
+
+/** This macro clears a flag within a bit mask */
+#define OO_CLRFLAG(flags,mask) (flags &= ~(ASN1UINT)mask)
+
+/** This macro tests a flag with a bit mask */
+#define OO_TESTFLAG(flags,mask) (((ASN1UINT)flags & (ASN1UINT)mask) != 0)
+
+
+
+/*TODO: Should add caller-id, callername etc. So that they can be changed per
+  call basis*/
+/**
+ * This structure defines options that can be set at the level of an 
+ * individual call. They override options set in the H.323 endpoint 
+ * structure.
+ */
+typedef struct ooCallOptions {
+   OOBOOL fastStart;    /*!< Use FastStart signaling */
+   OOBOOL tunneling;    /*!< Use H.245 tunneling */
+   OOBOOL disableGk;    /*!< Disable use of gatekeeper */
+   OOCallMode callMode; /*!< Type of channel to setup with FastStart */
+}ooCallOptions;
+ 
+
+struct OOH323CallData;
+
+typedef struct ooTimerCallback{
+   struct OOH323CallData* call;
+   ASN1UINT    timerType;
+   ASN1UINT    channelNumber;
+} ooTimerCallback;
+
+/**
+ * @}
+ */
+#endif
+
diff --git a/addons/ooh323c/src/perutil.c b/addons/ooh323c/src/perutil.c
new file mode 100644
index 000000000..c3c7b3696
--- /dev/null
+++ b/addons/ooh323c/src/perutil.c
@@ -0,0 +1,287 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooasn1.h"
+#include "ooper.h"
+
+ASN1BOOL isExtendableSize (Asn1SizeCnst* pSizeList);
+static ASN1BOOL isFixedSize (Asn1SizeCnst* pSizeList);
+
+ASN1BOOL alignCharStr 
+(OOCTXT* pctxt, ASN1UINT len, ASN1UINT nbits, Asn1SizeCnst* pSize)
+{
+   if (TRUE) {
+      ASN1UINT lower, upper;
+      ASN1BOOL doAlign = (len > 0), extendable;
+
+      pSize = checkSize (pSize, len, &extendable);
+
+      if (0 != pSize) {
+         lower = pSize->lower;
+         upper = pSize->upper;
+      }
+      else {
+         lower = 0;
+         upper = ASN1UINT_MAX;
+      }
+
+      if (!extendable && upper < 65536) {
+         ASN1UINT bitRange = upper * nbits;
+         if (upper == lower) {
+            /* X.691, clause 26.5.6 */
+            if (bitRange <= 16) doAlign = FALSE;
+         }
+         else {
+            /* X.691, clause 26.5.7 */
+            if (bitRange < 16) doAlign = FALSE;
+         }
+      }
+
+      return doAlign;
+   }
+   else
+      return FALSE;
+}
+
+int bitAndOctetStringAlignmentTest (Asn1SizeCnst* pSizeList, 
+                                    ASN1UINT itemCount, 
+                                    ASN1BOOL bitStrFlag,
+                                    ASN1BOOL* pAlignFlag)
+{
+   ASN1UINT threshold = (bitStrFlag) ? 16 : 2;
+
+   if (pSizeList == 0 || itemCount > threshold) 
+      *pAlignFlag = TRUE;
+   else if (isFixedSize(pSizeList)) 
+      *pAlignFlag = FALSE;
+   else {
+
+      /* Variable length case: check size.. no alignment required if    */
+      /* lower == upper and not extended..                              */
+
+      ASN1BOOL extended;
+      Asn1SizeCnst* pSize = checkSize (pSizeList, itemCount, &extended);
+
+      if (pSize != 0)
+         *pAlignFlag = ((pSize->upper != pSize->lower) || pSize->extended);
+      else {
+         /* Note: we never should get here because constraint           */
+         /* violation should have been caught when length was encoded   */
+         /* or decoded..                                                */
+         return (ASN_E_CONSVIO);
+      }
+   }
+
+   return (ASN_OK);
+}
+
+Asn1SizeCnst* checkSize (Asn1SizeCnst* pSizeList, 
+                         ASN1UINT value, 
+                         ASN1BOOL* pExtendable)
+{
+   Asn1SizeCnst* lpSize = pSizeList;
+   *pExtendable = isExtendableSize (lpSize);
+
+   while (lpSize) {
+      if (value >= lpSize->lower && value <= lpSize->upper) {
+         return (lpSize);
+      }
+      else lpSize = lpSize->next;
+   }
+
+   return 0;
+}
+
+int getPERMsgLen (OOCTXT* pctxt)
+{
+   return (pctxt->buffer.bitOffset == 8) ?
+      pctxt->buffer.byteIndex : pctxt->buffer.byteIndex + 1;
+}
+
+int addSizeConstraint (OOCTXT* pctxt, Asn1SizeCnst* pSize)
+{
+   Asn1SizeCnst* lpSize;
+   int stat = ASN_OK;
+
+   /* If constraint does not already exist, add it */
+
+   if (!pctxt->pSizeConstraint) {
+      pctxt->pSizeConstraint = pSize;
+   }
+
+   /* Otherwise, check to make sure given constraint is larger than     */
+   /* the existing constraint..                                         */
+
+   else {
+      lpSize = pSize;
+      while (lpSize) {
+         if (pctxt->pSizeConstraint->lower <= lpSize->lower ||
+             pctxt->pSizeConstraint->upper >= lpSize->upper) 
+         {
+            /* Set the extension flag to the value of the size          */
+            /* constraint structure that the item falls within..        */
+
+            /* pctxt->pSizeConstraint->extended = lpSize->extended; */
+
+            break;
+         }
+         lpSize = lpSize->next;
+      }
+
+      if (!lpSize)
+         stat = ASN_E_CONSVIO;
+   }
+
+   return stat;
+}
+
+Asn1SizeCnst* getSizeConstraint (OOCTXT* pctxt, ASN1BOOL extbit)
+{
+   Asn1SizeCnst* lpSize = pctxt->pSizeConstraint;
+
+   while (lpSize) {
+      if (lpSize->extended == extbit)
+         return lpSize;
+      else
+         lpSize = lpSize->next;
+   }
+
+   return NULL;
+}
+
+int checkSizeConstraint(OOCTXT* pctxt, int size)
+{
+   Asn1SizeCnst* pSize;
+   ASN1UINT lower, upper;
+   ASN1BOOL extbit;
+   int      stat;
+
+   /* If size constraint is present and extendable, decode extension    */
+   /* bit..                                                             */
+
+   if (isExtendableSize(pctxt->pSizeConstraint)) {
+      stat = DE_BIT (pctxt, &extbit);
+      if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
+   }
+   else extbit = 0;
+
+   /* Now use the value of the extension bit to select the proper       */
+   /* size constraint range specification..                             */
+
+   pSize = getSizeConstraint (pctxt, extbit);
+
+   lower = (pSize) ? pSize->lower : 0;
+   upper = (pSize) ? pSize->upper : ASN1UINT_MAX;
+
+   if (upper < (ASN1UINT)size) {
+      return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO);
+   }
+
+   return ASN_OK;
+}
+
+ASN1UINT getUIntBitCount (ASN1UINT value)
+{ 
+   /* Binary search - decision tree (5 tests, rarely 6) */
+   return
+      ((value < 1<<15) ?
+       ((value < 1<<7) ?
+        ((value < 1<<3) ?
+         ((value < 1<<1) ? ((value < 1<<0) ? 0 : 1) : 
+          ((value < 1<<2) ? 2 : 3)) :
+         ((value < 1<<5) ? ((value < 1<<4) ? 4 : 5) : 
+          ((value < 1<<6) ? 6 : 7))) :
+        ((value < 1<<11) ?
+         ((value < 1<<9) ? ((value < 1<<8) ? 8 : 9) : 
+          ((value < 1<<10) ? 10 : 11)) :
+         ((value < 1<<13) ? ((value < 1<<12) ? 12 : 13) : 
+          ((value < 1<<14) ? 14 : 15)))) :
+       ((value < 1<<23) ?
+        ((value < 1<<19) ?
+         ((value < 1<<17) ? ((value < 1<<16) ? 16 : 17) : 
+          ((value < 1<<18) ? 18 : 19)) :
+         ((value < 1<<21) ? ((value < 1<<20) ? 20 : 21) : 
+          ((value < 1<<22) ? 22 : 23))) :
+        ((value < 1<<27) ?
+         ((value < 1<<25) ? ((value < 1<<24) ? 24 : 25) : 
+          ((value < 1<<26) ? 26 : 27)) :
+         ((value < 1<<29) ? ((value < 1<<28) ? 28 : 29) : 
+          ((value < 1<<30) ? 30 : 
+           ((value < 1UL<<31) ? 31 : 32))))));
+}
+
+void init16BitCharSet (Asn116BitCharSet* pCharSet, ASN116BITCHAR first,
+                       ASN116BITCHAR last, ASN1UINT abits, ASN1UINT ubits)
+{
+   pCharSet->charSet.nchars = 0;
+   pCharSet->charSet.data = 0;
+   pCharSet->firstChar = first;
+   pCharSet->lastChar  = last;
+   pCharSet->unalignedBits = ubits;
+   pCharSet->alignedBits = abits;
+}
+
+ASN1BOOL isExtendableSize (Asn1SizeCnst* pSizeList)
+{
+   Asn1SizeCnst* lpSize = pSizeList;
+   while (lpSize) {
+      if (lpSize->extended)
+         return TRUE;
+      else
+         lpSize = lpSize->next;
+   }
+   return FALSE;
+}
+
+static ASN1BOOL isFixedSize (Asn1SizeCnst* pSizeList)
+{
+   Asn1SizeCnst* lpSize = pSizeList;
+   if (lpSize && !lpSize->extended && !lpSize->next) {
+      return (ASN1BOOL) (lpSize->lower == lpSize->upper);
+   }
+   return FALSE;
+}
+
+void set16BitCharSet 
+(OOCTXT* pctxt, Asn116BitCharSet* pCharSet, Asn116BitCharSet* pAlphabet)
+{
+   /* Permitted alphabet range can either be specified as a range of    */
+   /* characters or as a discrete set..                                 */
+
+   if (pAlphabet->charSet.data) {
+      int nocts = pAlphabet->charSet.nchars * 2;
+      pCharSet->charSet.nchars = pAlphabet->charSet.nchars;
+
+      pCharSet->charSet.data = 
+         (ASN116BITCHAR*) ASN1MALLOC (pctxt, nocts);
+
+      if (pCharSet->charSet.data != NULL)
+         memcpy (pCharSet->charSet.data, pAlphabet->charSet.data, nocts);
+   }
+   else {
+      pCharSet->firstChar = pAlphabet->firstChar;
+      pCharSet->lastChar  = pAlphabet->lastChar;
+      pCharSet->charSet.nchars = pCharSet->lastChar - pCharSet->firstChar;
+   }
+
+   pCharSet->unalignedBits = getUIntBitCount (pCharSet->charSet.nchars);
+
+   pCharSet->alignedBits = 1;
+   while (pCharSet->unalignedBits > pCharSet->alignedBits)
+      pCharSet->alignedBits <<= 1;
+
+}
+
diff --git a/addons/ooh323c/src/printHandler.c b/addons/ooh323c/src/printHandler.c
new file mode 100644
index 000000000..097aac877
--- /dev/null
+++ b/addons/ooh323c/src/printHandler.c
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/* This is an implementation of a simple print handler.  It outputs 
+   the fields of an encoded PER message to stdout in a structured output 
+   format..
+*/
+#include <stdlib.h>
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+#include "printHandler.h"
+#include "ootypes.h"
+#include "rtctype.h"
+#include "ootrace.h"
+
+EventHandler printHandler;
+
+static const char* pVarName;
+static int gIndentSpaces;
+
+static const char* bitStrToString 
+(ASN1UINT numbits, const ASN1OCTET* data, char* buffer, size_t bufsiz);
+
+static const char* octStrToString 
+(ASN1UINT numocts, const ASN1OCTET* data, char* buffer, size_t bufsiz);
+
+void initializePrintHandler(EventHandler *printHandler, char * varname)
+{
+   printHandler->startElement = &printStartElement;
+   printHandler->endElement = &printEndElement;
+   printHandler->boolValue = &printBoolValue;
+   printHandler->intValue = &printIntValue;
+   printHandler->uIntValue = &printuIntValue ;
+   printHandler->bitStrValue = &printBitStrValue;
+   printHandler->octStrValue = &printOctStrValue;
+   printHandler->charStrValue = &printCharStrValue;
+   printHandler->charStr16BitValue = &printCharStr16BitValue ;
+   printHandler->nullValue = &printNullValue;
+   printHandler->oidValue = &printOidValue;
+   printHandler->enumValue = &printEnumValue;
+   printHandler->openTypeValue = &printOpenTypeValue;
+   pVarName = varname;
+   OOTRACEDBGB2("%s = {\n", pVarName);
+   gIndentSpaces += 3;
+
+}
+
+void finishPrint()
+{
+   OOTRACEDBGB1 ("}\n");
+   gIndentSpaces -= 3;
+   if (gIndentSpaces != 0) {
+      OOTRACEDBGB1 ("ERROR: unbalanced structure\n");
+   }
+}
+
+void indent ()
+{
+   int i=0;
+   for (i = 0; i < gIndentSpaces; i++) OOTRACEDBGB1 (" ");
+}
+
+void printStartElement (const char* name, int index)
+{
+   indent ();
+   OOTRACEDBGB1 (name);
+   if (index >= 0) OOTRACEDBGB2 ("[%d]", index);
+   OOTRACEDBGB1 (" = {\n");
+   gIndentSpaces += 3;
+}
+
+void printEndElement (const char* name, int index)
+{
+   gIndentSpaces -= 3;
+   indent ();
+   OOTRACEDBGB1 ("}\n");
+}
+
+void printBoolValue (ASN1BOOL value)
+{
+   const char* s = value ? "TRUE" : "FALSE";
+   indent ();
+   OOTRACEDBGB2 ("%s\n", s);
+}
+
+void printIntValue (ASN1INT value)
+{
+   indent ();
+   OOTRACEDBGB2 ("%d\n", value);
+}
+
+void printuIntValue (ASN1UINT value)
+{
+   indent ();
+   OOTRACEDBGB2 ("%u\n", value);
+}
+
+void printBitStrValue (ASN1UINT numbits, const ASN1OCTET* data)
+{
+#ifdef __MINGW32__
+   char s[numbits + 8];
+   indent ();
+   OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8));
+#else
+   char* s = (char*)malloc(numbits + 8);
+   indent ();
+   OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8));
+   free(s);
+#endif
+}
+
+void printOctStrValue (ASN1UINT numocts, const ASN1OCTET* data)
+{
+   int bufsiz = (numocts * 2) + 8;
+#ifdef __MINGW32__
+   char s[bufsiz];
+   indent ();
+   OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz));
+#else
+   char* s = (char*)malloc(bufsiz);
+   indent ();
+   OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz));
+   free(s);
+#endif
+}
+
+void printCharStrValue (const char* value)
+{
+   indent ();
+   OOTRACEDBGB2 ("\"%s\"\n", value);
+}
+
+void printCharStr16BitValue (ASN1UINT nchars, ASN116BITCHAR* data)
+{
+   ASN1UINT ui;
+   indent ();
+
+   for (ui = 0; ui < nchars; ui++) {
+      if (data[ui] >= 32 && data[ui] <= 127)
+         OOTRACEDBGB2 ("%c", (char)data[ui]);
+      else
+         OOTRACEDBGB1 ("?");
+   }
+
+   OOTRACEDBGB1 ("\n");
+}
+
+void printCharStr32BitValue (ASN1UINT nchars, ASN132BITCHAR* data)
+{
+   ASN1UINT ui;
+   indent ();
+
+   for ( ui = 0; ui < nchars; ui++) {
+      if (data[ui] >= 32 && data[ui] <= 127)
+         OOTRACEDBGB2 ("%c", (char)data[ui]);
+      else
+         OOTRACEDBGB2 ("\\%d", data[ui]);
+   }
+
+   OOTRACEDBGB1 ("\n");
+}
+
+void printNullValue ()
+{
+   indent ();
+   OOTRACEDBGB1 ("NULL\n");
+}
+
+void ooPrintOIDValue (ASN1OBJID* pOID)
+{
+   ASN1UINT ui;
+   OOTRACEDBGB1 ("{ \n");
+   for (ui = 0; ui < pOID->numids; ui++) {
+      OOTRACEDBGB2 ("%d ", pOID->subid[ui]);
+   }
+   OOTRACEDBGB1 ("}\n");
+}
+
+void printOidValue (ASN1UINT numSubIds, ASN1UINT* pSubIds)
+{
+   ASN1UINT ui;
+   ASN1OBJID oid;
+   oid.numids = numSubIds;
+
+   for ( ui = 0; ui < numSubIds; ui++)
+      oid.subid[ui] = pSubIds[ui];
+
+   indent ();
+   ooPrintOIDValue (&oid);
+}
+
+void printRealValue (double value)
+{
+   indent ();
+   OOTRACEDBGB2 ("%f\n", value);
+}
+
+void printEnumValue (ASN1UINT value)
+{
+   indent ();
+   OOTRACEDBGB2 ("%u\n", value);
+}
+
+void printOpenTypeValue (ASN1UINT numocts, const ASN1OCTET* data)
+{
+   indent ();
+   OOTRACEDBGB1 ("< encoded data >\n");
+}
+
+static const char* bitStrToString 
+(ASN1UINT numbits, const ASN1OCTET* data, char* buffer, size_t bufsiz)
+{
+   size_t i;
+   unsigned char mask = 0x80;
+
+   if (bufsiz > 0) {
+      buffer[0] = '\'';
+      for (i = 0; i < numbits; i++) {
+         if (i < bufsiz - 1) {
+            buffer[i+1] = (char) (((data[i/8] & mask) != 0) ? '1' : '0');
+            mask >>= 1;
+            if (0 == mask) mask = 0x80;
+         }
+         else break;
+      }
+     i++;
+      if (i < bufsiz - 1) buffer[i++] = '\'';
+      if (i < bufsiz - 1) buffer[i++] = 'B';
+      if (i < bufsiz - 1) buffer[i] = '\0';
+      else buffer[bufsiz - 1] = '\0';
+   }
+
+   return buffer;
+}
+
+static const char* octStrToString 
+(ASN1UINT numocts, const ASN1OCTET* data, char* buffer, size_t bufsiz)
+{
+   size_t i;
+   char lbuf[4];
+
+   if (bufsiz > 0) {
+      buffer[0] = '\'';
+      if (bufsiz > 1) buffer[1] = '\0';
+      for (i = 0; i < numocts; i++) {
+         if (i < bufsiz - 1) {
+            sprintf (lbuf, "%02x", data[i]);
+            strcat (&buffer[(i*2)+1], lbuf);
+         }
+         else break;
+      }
+     i = i*2 + 1;
+      if (i < bufsiz - 1) buffer[i++] = '\'';
+      if (i < bufsiz - 1) buffer[i++] = 'H';
+      if (i < bufsiz - 1) buffer[i] = '\0';
+      else buffer[bufsiz - 1] = '\0';
+   }
+
+   return buffer;
+}
diff --git a/addons/ooh323c/src/printHandler.h b/addons/ooh323c/src/printHandler.h
new file mode 100644
index 000000000..30d87295d
--- /dev/null
+++ b/addons/ooh323c/src/printHandler.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+/**
+   @file printHandler.h  
+   This is an implementation of a simple print handler.  It outputs 
+   the fields of an encoded PER message to stdout in a structured output 
+   format..
+*/
+
+#ifndef _PRINTHANDLER_H_
+#define _PRINTHANDLER_H_
+
+#include "eventHandler.h"
+
+extern EventHandler printHandler;
+
+void initializePrintHandler(EventHandler *printHandler, char * varname);
+void finishPrint();
+void indent ();
+void printStartElement (const char* name, int index );
+void printEndElement (const char* name, int index );
+void printBoolValue (ASN1BOOL value);
+void printIntValue (ASN1INT value);
+void printuIntValue (ASN1UINT value);
+void printBitStrValue (ASN1UINT numbits, const ASN1OCTET* data);
+void printOctStrValue (ASN1UINT numocts, const ASN1OCTET* data);
+void printCharStrValue (const char* value);
+void printCharStr16BitValue (ASN1UINT nchars, ASN116BITCHAR* data);
+void printNullValue ();
+void printOidValue (ASN1UINT numSubIds, ASN1UINT* pSubIds);
+void printEnumValue (ASN1UINT value);
+void printOpenTypeValue (ASN1UINT numocts, const ASN1OCTET* data);
+
+#endif
diff --git a/addons/ooh323c/src/rtctype.c b/addons/ooh323c/src/rtctype.c
new file mode 100644
index 000000000..4ea7977f3
--- /dev/null
+++ b/addons/ooh323c/src/rtctype.c
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/* Run-time ctype substitution */
+
+#include "ooasn1.h"
+#include "rtctype.h"
+
+const ASN1OCTET rtCtypeTable[256] = {
+   OS_CTYPE_CTRL,                   /* 00 (NUL) */
+   OS_CTYPE_CTRL,                   /* 01 (SOH) */
+   OS_CTYPE_CTRL,                   /* 02 (STX) */
+   OS_CTYPE_CTRL,                   /* 03 (ETX) */
+   OS_CTYPE_CTRL,                   /* 04 (EOT) */
+   OS_CTYPE_CTRL,                   /* 05 (ENQ) */
+   OS_CTYPE_CTRL,                   /* 06 (ACK) */
+   OS_CTYPE_CTRL,                   /* 07 (BEL) */
+   OS_CTYPE_CTRL,                   /* 08 (BS)  */
+   OS_CTYPE_CTRL|OS_CTYPE_SPACE,    /* 09 (HT)  */
+   OS_CTYPE_CTRL|OS_CTYPE_SPACE,    /* 0A (LF)  */
+   OS_CTYPE_CTRL|OS_CTYPE_SPACE,    /* 0B (VT)  */
+   OS_CTYPE_CTRL|OS_CTYPE_SPACE,    /* 0C (FF)  */
+   OS_CTYPE_CTRL|OS_CTYPE_SPACE,    /* 0D (CR)  */
+   OS_CTYPE_CTRL,                   /* 0E (SI)  */
+   OS_CTYPE_CTRL,                   /* 0F (SO)  */
+   OS_CTYPE_CTRL,                   /* 10 (DLE) */
+   OS_CTYPE_CTRL,                   /* 11 (DC1) */
+   OS_CTYPE_CTRL,                   /* 12 (DC2) */
+   OS_CTYPE_CTRL,                   /* 13 (DC3) */
+   OS_CTYPE_CTRL,                   /* 14 (DC4) */
+   OS_CTYPE_CTRL,                   /* 15 (NAK) */
+   OS_CTYPE_CTRL,                   /* 16 (SYN) */
+   OS_CTYPE_CTRL,                   /* 17 (ETB) */
+   OS_CTYPE_CTRL,                   /* 18 (CAN) */
+   OS_CTYPE_CTRL,                   /* 19 (EM)  */
+   OS_CTYPE_CTRL,                   /* 1A (SUB) */
+   OS_CTYPE_CTRL,                   /* 1B (ESC) */
+   OS_CTYPE_CTRL,                   /* 1C (FS)  */
+   OS_CTYPE_CTRL,                   /* 1D (GS)  */
+   OS_CTYPE_CTRL,                   /* 1E (RS)  */
+   OS_CTYPE_CTRL,                   /* 1F (US)  */
+   OS_CTYPE_SPACE|OS_CTYPE_BLANK,   /* 20 SPACE */
+   OS_CTYPE_PUNCT,                  /* 21 !     */
+   OS_CTYPE_PUNCT,                  /* 22 "     */
+   OS_CTYPE_PUNCT,                  /* 23 #     */
+   OS_CTYPE_PUNCT,                  /* 24 $     */
+   OS_CTYPE_PUNCT,                  /* 25 %     */
+   OS_CTYPE_PUNCT,                  /* 26 &     */
+   OS_CTYPE_PUNCT,                  /* 27 '     */
+   OS_CTYPE_PUNCT,                  /* 28 (     */
+   OS_CTYPE_PUNCT,                  /* 29 )     */
+   OS_CTYPE_PUNCT,                  /* 2A *     */
+   OS_CTYPE_PUNCT,                  /* 2B +     */
+   OS_CTYPE_PUNCT,                  /* 2C ,     */
+   OS_CTYPE_PUNCT,                  /* 2D -     */
+   OS_CTYPE_PUNCT,                  /* 2E .     */
+   OS_CTYPE_PUNCT,                  /* 2F /     */
+   OS_CTYPE_NUMBER,                 /* 30 0     */
+   OS_CTYPE_NUMBER,                 /* 31 1     */
+   OS_CTYPE_NUMBER,                 /* 32 2     */
+   OS_CTYPE_NUMBER,                 /* 33 3     */
+   OS_CTYPE_NUMBER,                 /* 34 4     */
+   OS_CTYPE_NUMBER,                 /* 35 5     */
+   OS_CTYPE_NUMBER,                 /* 36 6     */
+   OS_CTYPE_NUMBER,                 /* 37 7     */
+   OS_CTYPE_NUMBER,                 /* 38 8     */
+   OS_CTYPE_NUMBER,                 /* 39 9     */
+   OS_CTYPE_PUNCT,                  /* 3A :     */
+   OS_CTYPE_PUNCT,                  /* 3B ;     */
+   OS_CTYPE_PUNCT,                  /* 3C <     */
+   OS_CTYPE_PUNCT,                  /* 3D =     */
+   OS_CTYPE_PUNCT,                  /* 3E >     */
+   OS_CTYPE_PUNCT,                  /* 3F ?     */
+   OS_CTYPE_PUNCT,                  /* 40 @     */
+   OS_CTYPE_UPPER|OS_CTYPE_HEX,     /* 41 A     */
+   OS_CTYPE_UPPER|OS_CTYPE_HEX,     /* 42 B     */
+   OS_CTYPE_UPPER|OS_CTYPE_HEX,     /* 43 C     */
+   OS_CTYPE_UPPER|OS_CTYPE_HEX,     /* 44 D     */
+   OS_CTYPE_UPPER|OS_CTYPE_HEX,     /* 45 E     */
+   OS_CTYPE_UPPER|OS_CTYPE_HEX,     /* 46 F     */
+   OS_CTYPE_UPPER,                  /* 47 G     */
+   OS_CTYPE_UPPER,                  /* 48 H     */
+   OS_CTYPE_UPPER,                  /* 49 I     */
+   OS_CTYPE_UPPER,                  /* 4A J     */
+   OS_CTYPE_UPPER,                  /* 4B K     */
+   OS_CTYPE_UPPER,                  /* 4C L     */
+   OS_CTYPE_UPPER,                  /* 4D M     */
+   OS_CTYPE_UPPER,                  /* 4E N     */
+   OS_CTYPE_UPPER,                  /* 4F O     */
+   OS_CTYPE_UPPER,                  /* 50 P     */
+   OS_CTYPE_UPPER,                  /* 51 Q     */
+   OS_CTYPE_UPPER,                  /* 52 R     */
+   OS_CTYPE_UPPER,                  /* 53 S     */
+   OS_CTYPE_UPPER,                  /* 54 T     */
+   OS_CTYPE_UPPER,                  /* 55 U     */
+   OS_CTYPE_UPPER,                  /* 56 V     */
+   OS_CTYPE_UPPER,                  /* 57 W     */
+   OS_CTYPE_UPPER,                  /* 58 X     */
+   OS_CTYPE_UPPER,                  /* 59 Y     */
+   OS_CTYPE_UPPER,                  /* 5A Z     */
+   OS_CTYPE_PUNCT,                  /* 5B [     */
+   OS_CTYPE_PUNCT,                  /* 5C \     */
+   OS_CTYPE_PUNCT,                  /* 5D ]     */
+   OS_CTYPE_PUNCT,                  /* 5E ^     */
+   OS_CTYPE_PUNCT,                  /* 5F _     */
+   OS_CTYPE_PUNCT,                  /* 60 `     */
+   OS_CTYPE_LOWER|OS_CTYPE_HEX,     /* 61 a     */
+   OS_CTYPE_LOWER|OS_CTYPE_HEX,     /* 62 b     */
+   OS_CTYPE_LOWER|OS_CTYPE_HEX,     /* 63 c     */
+   OS_CTYPE_LOWER|OS_CTYPE_HEX,     /* 64 d     */
+   OS_CTYPE_LOWER|OS_CTYPE_HEX,     /* 65 e     */
+   OS_CTYPE_LOWER|OS_CTYPE_HEX,     /* 66 f     */
+   OS_CTYPE_LOWER,                  /* 67 g     */
+   OS_CTYPE_LOWER,                  /* 68 h     */
+   OS_CTYPE_LOWER,                  /* 69 i     */
+   OS_CTYPE_LOWER,                  /* 6A j     */
+   OS_CTYPE_LOWER,                  /* 6B k     */
+   OS_CTYPE_LOWER,                  /* 6C l     */
+   OS_CTYPE_LOWER,                  /* 6D m     */
+   OS_CTYPE_LOWER,                  /* 6E n     */
+   OS_CTYPE_LOWER,                  /* 6F o     */
+   OS_CTYPE_LOWER,                  /* 70 p     */
+   OS_CTYPE_LOWER,                  /* 71 q     */
+   OS_CTYPE_LOWER,                  /* 72 r     */
+   OS_CTYPE_LOWER,                  /* 73 s     */
+   OS_CTYPE_LOWER,                  /* 74 t     */
+   OS_CTYPE_LOWER,                  /* 75 u     */
+   OS_CTYPE_LOWER,                  /* 76 v     */
+   OS_CTYPE_LOWER,                  /* 77 w     */
+   OS_CTYPE_LOWER,                  /* 78 x     */
+   OS_CTYPE_LOWER,                  /* 79 y     */
+   OS_CTYPE_LOWER,                  /* 7A z     */
+   OS_CTYPE_PUNCT,                  /* 7B {     */
+   OS_CTYPE_PUNCT,                  /* 7C |     */
+   OS_CTYPE_PUNCT,                  /* 7D }     */
+   OS_CTYPE_PUNCT,                  /* 7E ~     */
+   OS_CTYPE_CTRL,                   /* 7F (DEL) */
+
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0
+};
diff --git a/addons/ooh323c/src/rtctype.h b/addons/ooh323c/src/rtctype.h
new file mode 100644
index 000000000..ebb0a59b4
--- /dev/null
+++ b/addons/ooh323c/src/rtctype.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 1997-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+/** 
+ * @file rtctype.h 
+ */
+#ifndef _RTCTYPE_H_
+#define _RTCTYPE_H_
+
+#include "ooasn1.h"
+
+/* Ctype module constants */
+
+#define  OS_CTYPE_UPPER  0x1
+#define  OS_CTYPE_LOWER  0x2
+#define  OS_CTYPE_NUMBER 0x4
+#define  OS_CTYPE_SPACE  0x8
+#define  OS_CTYPE_PUNCT  0x10
+#define  OS_CTYPE_CTRL   0x20
+#define  OS_CTYPE_HEX    0x40
+#define  OS_CTYPE_BLANK  0x80
+
+/* Ctype substitution macros */
+
+#define  OS_ISALPHA(c) \
+(rtCtypeTable[(unsigned)(c)]&(OS_CTYPE_UPPER|OS_CTYPE_LOWER))
+#define  OS_ISUPPER(c)  \
+(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_UPPER)
+#define  OS_ISLOWER(c)  \
+(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_LOWER)
+#define  OS_ISDIGIT(c)  \
+(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_NUMBER)
+#define  OS_ISXDIGIT(c) \
+(rtCtypeTable[(unsigned)(c)]&(OS_CTYPE_HEX|OS_CTYPE_NUMBER))
+#define  OS_ISSPACE(c)  \
+(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_SPACE)
+#define  OS_ISPUNCT(c)  \
+(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_PUNCT)
+#define  OS_ISALNUM(c)  \
+(rtCtypeTable[(unsigned)(c)]&(OS_CTYPE_UPPER|OS_CTYPE_LOWER|OS_CTYPE_NUMBER))
+#define  OS_ISPRINT(c)  \
+(rtCtypeTable[(unsigned)(c)]& \
+(OS_CTYPE_PUNCT|OS_CTYPE_UPPER|OS_CTYPE_LOWER|OS_CTYPE_NUMBER|OS_CTYPE_BLANK))
+#define  OS_ISGRAPH(c)  \
+(rtCtypeTable[(unsigned)(c)]& \
+(OS_CTYPE_PUNCT|OS_CTYPE_UPPER|OS_CTYPE_LOWER|OS_CTYPE_NUMBER))
+#define  OS_ISCNTRL(c)  \
+(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_CTRL)
+
+#define  OS_TOLOWER(c) (OS_ISUPPER(c) ? (c) - 'A' + 'a' : (c))
+#define  OS_TOUPPER(c) (OS_ISLOWER(c) ? (c) - 'a' + 'A' : (c))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXTERN
+#ifdef MAKE_DLL
+#define EXTERN __declspec(dllexport)
+#else
+#define EXTERN
+#endif /* MAKE_DLL */
+#endif /* EXTERN */
+/* ctype module table */
+
+extern EXTERN const ASN1OCTET rtCtypeTable[256];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _RTCTYPE_H_ */
+
diff --git a/addons/ooh323cDriver.c b/addons/ooh323cDriver.c
new file mode 100644
index 000000000..5d7396abf
--- /dev/null
+++ b/addons/ooh323cDriver.c
@@ -0,0 +1,361 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+#include "ooh323cDriver.h"
+
+#include <asterisk/pbx.h>
+#include <asterisk/logger.h>
+#include <asterisk/options.h>
+
+extern OOBOOL gH323Debug;
+/* ooh323c stack thread. */
+static pthread_t ooh323c_thread = AST_PTHREADT_NULL;
+static int grxframes = 240;
+
+static int gtxframes = 20;
+
+int ooh323c_start_receive_channel(ooCallData *call, ooLogicalChannel *pChannel);
+int ooh323c_start_transmit_channel(ooCallData *call, ooLogicalChannel *pChannel);
+int ooh323c_stop_receive_channel(ooCallData *call, ooLogicalChannel *pChannel);
+int ooh323c_stop_transmit_channel(ooCallData *call, ooLogicalChannel *pChannel);
+
+void* ooh323c_stack_thread(void* dummy)
+{
+
+  ooMonitorChannels();
+  return dummy;
+}
+
+int ooh323c_start_stack_thread()
+{
+   if(ast_pthread_create(&ooh323c_thread, NULL, ooh323c_stack_thread, NULL) < 0)
+   {
+      ast_log(LOG_ERROR, "Unable to start ooh323c thread.\n");
+      return -1;
+   }
+   return 0;
+}
+
+int ooh323c_stop_stack_thread(void)
+{
+   if(ooh323c_thread !=  AST_PTHREADT_NULL)
+   {
+      ooStopMonitor();
+      pthread_join(ooh323c_thread, NULL);
+      ooh323c_thread =  AST_PTHREADT_NULL;
+   }
+   return 0;
+}
+
+int ooh323c_set_capability
+   (struct ast_codec_pref *prefs, int capability, int dtmf)
+{
+   int ret, x, format=0;
+   if(gH323Debug)
+     ast_verbose("\tAdding capabilities to H323 endpoint\n");
+   
+   for(x=0; 0 != (format=ast_codec_pref_index(prefs, x)); x++)
+   {
+      if(format & AST_FORMAT_ULAW)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding g711 ulaw capability to H323 endpoint\n");
+         ret= ooH323EpAddG711Capability(OO_G711ULAW64K, gtxframes, grxframes, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+      }
+      if(format & AST_FORMAT_ALAW)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding g711 alaw capability to H323 endpoint\n");
+         ret= ooH323EpAddG711Capability(OO_G711ALAW64K, gtxframes, grxframes, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+      }
+
+      if(format & AST_FORMAT_G729A)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding g729A capability to H323 endpoint\n");
+         ret = ooH323EpAddG729Capability(OO_G729A, 2, 24, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+
+         if(gH323Debug)
+            ast_verbose("\tAdding g729 capability to H323 endpoint\n");
+         ret |= ooH323EpAddG729Capability(OO_G729, 2, 24, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+      }
+
+      if(format & AST_FORMAT_G723_1)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding g7231 capability to H323 endpoint\n");
+         ret = ooH323EpAddG7231Capability(OO_G7231, 4, 7, FALSE, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+
+      }
+
+      if(format & AST_FORMAT_H263)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding h263 capability to H323 endpoint\n");
+         ret = ooH323EpAddH263VideoCapability(OO_H263VIDEO, 1, 0, 0, 0, 0, 320*1024, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+
+      }
+
+      if(format & AST_FORMAT_GSM)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding gsm capability to H323 endpoint\n");
+         ret = ooH323EpAddGSMCapability(OO_GSMFULLRATE, 4, FALSE, FALSE, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+
+      }
+      
+   }
+   
+   if(dtmf & H323_DTMF_RFC2833)
+      ret |= ooH323EpEnableDTMFRFC2833(0);
+   else if(dtmf & H323_DTMF_H245ALPHANUMERIC)
+      ret |= ooH323EpEnableDTMFH245Alphanumeric();
+   else if(dtmf & H323_DTMF_H245SIGNAL)
+      ret |= ooH323EpEnableDTMFH245Signal();
+
+   return ret;
+}
+
+int ooh323c_set_capability_for_call
+   (ooCallData *call, struct ast_codec_pref *prefs, int capability, int dtmf)
+{
+   int ret, x, txframes;
+   int format=0;
+   if(gH323Debug)
+     ast_verbose("\tAdding capabilities to call(%s, %s)\n", call->callType, 
+                                                            call->callToken);
+   if(dtmf & H323_DTMF_RFC2833)
+      ret |= ooCallEnableDTMFRFC2833(call,0);
+   else if(dtmf & H323_DTMF_H245ALPHANUMERIC)
+      ret |= ooCallEnableDTMFH245Alphanumeric(call);
+   else if(dtmf & H323_DTMF_H245SIGNAL)
+      ret |= ooCallEnableDTMFH245Signal(call);
+
+
+   for(x=0; 0 !=(format=ast_codec_pref_index(prefs, x)); x++)
+   {
+      if(format & AST_FORMAT_ULAW)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding g711 ulaw capability to call(%s, %s)\n", 
+                                              call->callType, call->callToken);
+	 txframes = prefs->framing[x];
+         ret= ooCallAddG711Capability(call, OO_G711ULAW64K, txframes, 
+                                      grxframes, OORXANDTX, 
+                                      &ooh323c_start_receive_channel,
+                                      &ooh323c_start_transmit_channel,
+                                      &ooh323c_stop_receive_channel, 
+                                      &ooh323c_stop_transmit_channel);
+      }
+      if(format & AST_FORMAT_ALAW)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding g711 alaw capability to call(%s, %s)\n",
+                                            call->callType, call->callToken);
+         txframes = prefs->framing[x];
+         ret= ooCallAddG711Capability(call, OO_G711ALAW64K, txframes, 
+                                     grxframes, OORXANDTX, 
+                                     &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+      }
+
+      if(format & AST_FORMAT_G729A)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding g729A capability to call(%s, %s)\n",
+                                            call->callType, call->callToken);
+         txframes = (prefs->framing[x])/10;
+         ret= ooCallAddG729Capability(call, OO_G729A, txframes, 24, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+
+         if(gH323Debug)
+            ast_verbose("\tAdding g729 capability to call(%s, %s)\n",
+                                            call->callType, call->callToken);
+         ret|= ooCallAddG729Capability(call, OO_G729, txframes, 24, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+      }
+
+      if(format & AST_FORMAT_G723_1)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding g7231 capability to call (%s, %s)\n",
+                                           call->callType, call->callToken);
+         ret = ooCallAddG7231Capability(call, OO_G7231, 4, 7, FALSE, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+
+      }
+
+      if(format & AST_FORMAT_H263)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding h263 capability to call (%s, %s)\n",
+                                           call->callType, call->callToken);
+         ret = ooCallAddH263VideoCapability(call, OO_H263VIDEO, 1, 0, 0, 0, 0, 320*1024, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+
+      }
+
+      if(format & AST_FORMAT_GSM)
+      {
+         if(gH323Debug)
+            ast_verbose("\tAdding gsm capability to call(%s, %s)\n", 
+                                             call->callType, call->callToken);
+         ret = ooCallAddGSMCapability(call, OO_GSMFULLRATE, 4, FALSE, FALSE, 
+                                     OORXANDTX, &ooh323c_start_receive_channel,
+                                     &ooh323c_start_transmit_channel,
+                                     &ooh323c_stop_receive_channel, 
+                                     &ooh323c_stop_transmit_channel);
+      }
+   }
+}
+
+int ooh323c_set_aliases(ooAliases * aliases)
+{
+   ooAliases *cur = aliases;
+   while(cur)
+   {
+      switch(cur->type)
+      { 
+      case T_H225AliasAddress_dialedDigits:
+         ooH323EpAddAliasDialedDigits(cur->value);
+         break;
+      case T_H225AliasAddress_h323_ID:
+         ooH323EpAddAliasH323ID(cur->value);
+         break;
+      case T_H225AliasAddress_url_ID:
+         ooH323EpAddAliasURLID(cur->value);
+         break;
+      case T_H225AliasAddress_email_ID:
+         ooH323EpAddAliasEmailID(cur->value);
+         break;
+      default:
+         ast_debug(1, "Ignoring unknown alias type\n");
+      }
+      cur = cur->next;
+   }
+   return 1;
+}
+   
+int ooh323c_start_receive_channel(ooCallData *call, ooLogicalChannel *pChannel)
+{
+   int fmt=-1;
+   fmt = convertH323CapToAsteriskCap(pChannel->chanCap->cap);
+   if(fmt>0)
+      ooh323_set_read_format(call, fmt);
+   else{
+     ast_log(LOG_ERROR, "Invalid capability type for receive channel %s\n",
+                                                          call->callToken);
+     return -1;
+   }
+   return 1;
+}
+
+int ooh323c_start_transmit_channel(ooCallData *call, ooLogicalChannel *pChannel)
+{
+   int fmt=-1;
+   fmt = convertH323CapToAsteriskCap(pChannel->chanCap->cap);
+   if(fmt>0)
+      ooh323_set_write_format(call, fmt);
+   else{
+      ast_log(LOG_ERROR, "Invalid capability type for receive channel %s\n",
+                                                          call->callToken);
+      return -1;
+   }
+   setup_rtp_connection(call, pChannel->remoteIP, pChannel->remoteMediaPort);
+    return 1;
+}
+
+int ooh323c_stop_receive_channel(ooCallData *call, ooLogicalChannel *pChannel)
+{
+   return 1;
+}
+
+int ooh323c_stop_transmit_channel(ooCallData *call, ooLogicalChannel *pChannel)
+{
+   close_rtp_connection(call);
+   return 1;
+}
+
+int convertH323CapToAsteriskCap(int cap)
+{
+
+   switch(cap)
+   {
+      case OO_G711ULAW64K:
+         return AST_FORMAT_ULAW;
+      case OO_G711ALAW64K:
+         return AST_FORMAT_ALAW;
+      case OO_GSMFULLRATE:
+         return AST_FORMAT_GSM;
+      case OO_G729:
+         return AST_FORMAT_G729A;
+      case OO_G729A:
+         return AST_FORMAT_G729A;
+      case OO_G7231:
+         return AST_FORMAT_G723_1;
+      case OO_H263VIDEO:
+         return AST_FORMAT_H263;
+      default:
+         ast_debug(1, "Cap %d is not supported by driver yet\n", cap);
+         return -1;
+   }
+
+   return -1;
+}
+
+ 
diff --git a/addons/ooh323cDriver.h b/addons/ooh323cDriver.h
new file mode 100644
index 000000000..ebd965131
--- /dev/null
+++ b/addons/ooh323cDriver.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be 
+ * used and copied only in accordance with the terms of this license. 
+ * The text of the license may generally be found in the root 
+ * directory of this installation in the COPYING file.  It 
+ * can also be viewed online at the following URL:
+ *
+ *   http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must 
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+#ifndef _OO_H323CDRIVER_H_
+#define __OO_H323DRIVER_H_
+#include "chan_ooh323.h"
+#include "ootypes.h"
+#include "ooh323ep.h"
+#include "oochannels.h"
+#include "ooCalls.h"
+#include "ooCapability.h"
+#include "ooStackCmds.h"
+#define H323_DTMF_RFC2833          (1 << 0)
+#define H323_DTMF_Q931             (1 << 1)
+#define H323_DTMF_H245ALPHANUMERIC (1 << 2)
+#define H323_DTMF_H245SIGNAL       (1 << 3)
+#define H323_DTMF_INBAND           (1 << 4)
+
+struct h323_pvt;
+int ooh323c_start_stack_thread(void);
+int ooh323c_stop_stack_thread(void);
+int ooh323c_set_capability
+   (struct ast_codec_pref *prefs, int capability, int dtmf);
+int convertH323CapToAsteriskCap(int cap);
+int ooh323c_set_capability_for_call
+   (ooCallData *call, struct ast_codec_pref *prefs, int capability, int dtmf);
+#endif
diff --git a/addons/res_config_mysql.c b/addons/res_config_mysql.c
new file mode 100644
index 000000000..2cd1fa4f4
--- /dev/null
+++ b/addons/res_config_mysql.c
@@ -0,0 +1,1752 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999-2005, Digium, Inc.
+ *
+ * Mark Spencer <markster@digium.com>  - Asterisk Author
+ * Matthew Boehm <mboehm@cytelcom.com> - MySQL RealTime Driver Author
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ * \brief MySQL CDR backend
+ */
+
+/*** MODULEINFO
+	<depend>mysqlclient</depend>
+	<defaultenabled>no</defaultenabled>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <sys/stat.h>
+
+#include <mysql/mysql.h>
+#include <mysql/mysql_version.h>
+#include <mysql/errmsg.h>
+
+#include "asterisk/channel.h"
+#include "asterisk/logger.h"
+#include "asterisk/config.h"
+#include "asterisk/module.h"
+#include "asterisk/lock.h"
+#include "asterisk/options.h"
+#include "asterisk/cli.h"
+#include "asterisk/utils.h"
+#include "asterisk/threadstorage.h"
+
+#define RES_CONFIG_MYSQL_CONF "res_mysql.conf"
+#define	READHANDLE	0
+#define	WRITEHANDLE	1
+
+#define ESCAPE_STRING(buf, var) \
+	do { \
+		if ((valsz = strlen(var)) * 2 + 1 > ast_str_size(buf)) { \
+			ast_str_make_space(&(buf), valsz * 2 + 1); \
+		} \
+		mysql_real_escape_string(&dbh->handle, ast_str_buffer(buf), var, valsz); \
+	} while (0)
+
+AST_THREADSTORAGE(sql_buf);
+AST_THREADSTORAGE(sql2_buf);
+AST_THREADSTORAGE(find_buf);
+AST_THREADSTORAGE(scratch_buf);
+AST_THREADSTORAGE(modify_buf);
+AST_THREADSTORAGE(modify2_buf);
+AST_THREADSTORAGE(modify3_buf);
+
+enum requirements { RQ_WARN, RQ_CREATECLOSE, RQ_CREATECHAR };
+
+struct mysql_conn {
+	AST_RWLIST_ENTRY(mysql_conn) list;
+	ast_mutex_t	lock;
+	MYSQL       handle;
+	char        host[50];
+	char        name[50];
+	char        user[50];
+	char        pass[50];
+	char        sock[50];
+	int         port;
+	int         connected;
+	time_t      connect_time;
+	enum requirements requirements;
+	char        unique_name[0];
+};
+
+struct columns {
+	char *name;
+	char *type;
+	char *dflt;
+	char null;
+	int len;
+	AST_LIST_ENTRY(columns) list;
+};
+
+struct tables {
+	ast_mutex_t lock;
+	AST_LIST_HEAD_NOLOCK(mysql_columns, columns) columns;
+	AST_LIST_ENTRY(tables) list;
+	struct mysql_conn *database;
+	char name[0];
+};
+
+static AST_LIST_HEAD_STATIC(mysql_tables, tables);
+static AST_RWLIST_HEAD_STATIC(databases, mysql_conn);
+
+static int parse_config(int reload);
+static int mysql_reconnect(struct mysql_conn *conn);
+static char *handle_cli_realtime_mysql_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
+static char *handle_cli_realtime_mysql_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
+static int load_mysql_config(struct ast_config *config, const char *category, struct mysql_conn *conn);
+static int require_mysql(const char *database, const char *tablename, va_list ap);
+static int internal_require(const char *database, const char *table, ...) attribute_sentinel;
+
+static struct ast_cli_entry cli_realtime_mysql_status[] = {
+	AST_CLI_DEFINE(handle_cli_realtime_mysql_status, "Shows connection information for the MySQL RealTime driver"),
+	AST_CLI_DEFINE(handle_cli_realtime_mysql_cache, "Shows cached tables within the MySQL realtime driver"),
+};
+
+static struct mysql_conn *find_database(const char *database, int for_write)
+{
+	char *whichdb;
+	const char *ptr;
+	struct mysql_conn *cur;
+
+	if ((ptr = strchr(database, '/'))) {
+		/* Multiple databases encoded within string */
+		if (for_write) {
+			whichdb = ast_strdupa(ptr + 1);
+		} else {
+			whichdb = alloca(ptr - database + 1);
+			strncpy(whichdb, database, ptr - database);
+			whichdb[ptr - database] = '\0';
+		}
+	} else {
+		whichdb = ast_strdupa(database);
+	}
+
+	AST_RWLIST_RDLOCK(&databases);
+	AST_RWLIST_TRAVERSE(&databases, cur, list) {
+		if (!strcmp(cur->unique_name, whichdb)) {
+			ast_mutex_lock(&cur->lock);
+			break;
+		}
+	}
+	AST_RWLIST_UNLOCK(&databases);
+	return cur;
+}
+
+#define release_database(a)	ast_mutex_unlock(&(a)->lock)
+
+static int internal_require(const char *database, const char *table, ...)
+{
+	va_list ap;
+	int res;
+	va_start(ap, table);
+	res = require_mysql(database, table, ap);
+	va_end(ap);
+	return res;
+}
+
+static void destroy_table(struct tables *table)
+{
+	struct columns *column;
+	ast_mutex_lock(&table->lock);
+	while ((column = AST_LIST_REMOVE_HEAD(&table->columns, list))) {
+		ast_free(column);
+	}
+	ast_mutex_unlock(&table->lock);
+	ast_mutex_destroy(&table->lock);
+	ast_free(table);
+}
+
+static struct tables *find_table(const char *database, const char *tablename)
+{
+	struct columns *column;
+	struct tables *table;
+	struct ast_str *sql = ast_str_thread_get(&find_buf, 30);
+	char *fname, *ftype, *flen, *fdflt, *fnull;
+	struct mysql_conn *dbh;
+	MYSQL_RES *result;
+	MYSQL_ROW row;
+
+	if (!(dbh = find_database(database, 1))) {
+		return NULL;
+	}
+
+	AST_LIST_LOCK(&mysql_tables);
+	AST_LIST_TRAVERSE(&mysql_tables, table, list) {
+		if (!strcasecmp(table->name, tablename)) {
+			ast_mutex_lock(&table->lock);
+			AST_LIST_UNLOCK(&mysql_tables);
+			release_database(dbh);
+			return table;
+		}
+	}
+
+	/* Not found, scan the table */
+	ast_str_set(&sql, 0, "DESC %s", tablename);
+
+	if (!mysql_reconnect(dbh)) {
+		release_database(dbh);
+		AST_LIST_UNLOCK(&mysql_tables);
+		return NULL;
+	}
+
+	if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+		ast_log(LOG_ERROR, "Failed to query database columns: %s\n", mysql_error(&dbh->handle));
+		release_database(dbh);
+		AST_LIST_UNLOCK(&mysql_tables);
+		return NULL;
+	}
+
+	if (!(table = ast_calloc(1, sizeof(*table) + strlen(tablename) + 1))) {
+		ast_log(LOG_ERROR, "Unable to allocate memory for new table structure\n");
+		release_database(dbh);
+		AST_LIST_UNLOCK(&mysql_tables);
+		return NULL;
+	}
+	strcpy(table->name, tablename); /* SAFE */
+	table->database = dbh;
+	ast_mutex_init(&table->lock);
+	AST_LIST_HEAD_INIT_NOLOCK(&table->columns);
+
+	if ((result = mysql_store_result(&dbh->handle))) {
+		while ((row = mysql_fetch_row(result))) {
+			fname = row[0];
+			ftype = row[1];
+			fnull = row[2];
+			fdflt = row[4];
+			ast_verb(4, "Found column '%s' of type '%s'\n", fname, ftype);
+
+			if (fdflt == NULL) {
+				fdflt = "";
+			}
+
+			if (!(column = ast_calloc(1, sizeof(*column) + strlen(fname) + strlen(ftype) + strlen(fdflt) + 3))) {
+				ast_log(LOG_ERROR, "Unable to allocate column element for %s, %s\n", tablename, fname);
+				destroy_table(table);
+				release_database(dbh);
+				AST_LIST_UNLOCK(&mysql_tables);
+				return NULL;
+			}
+
+			if ((flen = strchr(ftype, '('))) {
+				sscanf(flen, "(%d)", &column->len);
+			} else {
+				/* Columns like dates, times, and timestamps don't have a length */
+				column->len = -1;
+			}
+
+			column->name = (char *)column + sizeof(*column);
+			column->type = (char *)column + sizeof(*column) + strlen(fname) + 1;
+			column->dflt = (char *)column + sizeof(*column) + strlen(fname) + 1 + strlen(ftype) + 1;
+			strcpy(column->name, fname);
+			strcpy(column->type, ftype);
+			strcpy(column->dflt, fdflt);
+			column->null = (strcmp(fnull, "YES") == 0 ? 1 : 0);
+			AST_LIST_INSERT_TAIL(&table->columns, column, list);
+		}
+		mysql_free_result(result);
+	}
+
+	AST_LIST_INSERT_TAIL(&mysql_tables, table, list);
+	ast_mutex_lock(&table->lock);
+	AST_LIST_UNLOCK(&mysql_tables);
+	release_database(dbh);
+	return table;
+}
+
+static void release_table(struct tables *table)
+{
+	if (table) {
+		ast_mutex_unlock(&table->lock);
+	}
+}
+
+static struct columns *find_column(struct tables *table, const char *colname)
+{
+	struct columns *column;
+
+	AST_LIST_TRAVERSE(&table->columns, column, list) {
+		if (strcmp(column->name, colname) == 0) {
+			break;
+		}
+	}
+
+	return column;
+}
+
+static struct ast_variable *realtime_mysql(const char *database, const char *table, va_list ap)
+{
+	struct mysql_conn *dbh;
+	MYSQL_RES *result;
+	MYSQL_ROW row;
+	MYSQL_FIELD *fields;
+	int numFields, i, valsz;
+	struct ast_str *sql = ast_str_thread_get(&sql_buf, 16);
+	struct ast_str *buf = ast_str_thread_get(&scratch_buf, 16);
+	char *stringp;
+	char *chunk;
+	char *op;
+	const char *newparam, *newval;
+	struct ast_variable *var=NULL, *prev=NULL;
+
+	if (!(dbh = find_database(database, 0))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: %s\n", database);
+		return NULL;
+	}
+
+	if (!table) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n");
+		release_database(dbh);
+		return NULL;
+	}
+
+	/* Get the first parameter and first value in our list of passed paramater/value pairs */
+	newparam = va_arg(ap, const char *);
+	newval = va_arg(ap, const char *);
+	if (!newparam || !newval)  {
+		ast_log(LOG_WARNING, "MySQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
+		release_database(dbh);
+		return NULL;
+	}
+
+	/* Must connect to the server before anything else, as the escape function requires the mysql handle. */
+	if (!mysql_reconnect(dbh)) {
+		release_database(dbh);
+		return NULL;
+	}
+
+	/* Create the first part of the query using the first parameter/value pairs we just extracted
+	   If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
+
+	if (!strchr(newparam, ' ')) 
+		op = " ="; 
+	else 
+		op = "";
+
+	ESCAPE_STRING(buf, newval);
+	ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s%s '%s'", table, newparam, op, ast_str_buffer(buf));
+	while ((newparam = va_arg(ap, const char *))) {
+		newval = va_arg(ap, const char *);
+		if (!strchr(newparam, ' ')) 
+			op = " ="; 
+		else
+			op = "";
+		ESCAPE_STRING(buf, newval);
+		ast_str_append(&sql, 0, " AND %s%s '%s'", newparam, op, ast_str_buffer(buf));
+	}
+	va_end(ap);
+
+	ast_debug(1, "MySQL RealTime: Retrieve SQL: %s\n", ast_str_buffer(sql));
+
+	/* Execution. */
+	if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle));
+		release_database(dbh);
+		return NULL;
+	}
+
+	if ((result = mysql_store_result(&dbh->handle))) {
+		numFields = mysql_num_fields(result);
+		fields = mysql_fetch_fields(result);
+
+		while ((row = mysql_fetch_row(result))) {
+			for (i = 0; i < numFields; i++) {
+				if (ast_strlen_zero(row[i]))
+					continue;
+				for (stringp = ast_strdupa(row[i]), chunk = strsep(&stringp, ";"); chunk; chunk = strsep(&stringp, ";")) {
+					if (!chunk || ast_strlen_zero(ast_strip(chunk))) {
+						continue;
+					}
+					if (prev) {
+						if ((prev->next = ast_variable_new(fields[i].name, chunk, ""))) {
+							prev = prev->next;
+						}
+					} else {
+						prev = var = ast_variable_new(fields[i].name, chunk, "");
+					}
+				}
+			}
+		}
+	} else {
+		ast_debug(1, "MySQL RealTime: Could not find any rows in table %s.\n", table);
+	}
+
+	release_database(dbh);
+	mysql_free_result(result);
+
+	return var;
+}
+
+static struct ast_config *realtime_multi_mysql(const char *database, const char *table, va_list ap)
+{
+	struct mysql_conn *dbh;
+	MYSQL_RES *result;
+	MYSQL_ROW row;
+	MYSQL_FIELD *fields;
+	int numFields, i, valsz;
+	struct ast_str *sql = ast_str_thread_get(&sql_buf, 16);
+	struct ast_str *buf = ast_str_thread_get(&scratch_buf, 16);
+	const char *initfield = NULL;
+	char *stringp;
+	char *chunk;
+	char *op;
+	const char *newparam, *newval;
+	struct ast_variable *var = NULL;
+	struct ast_config *cfg = NULL;
+	struct ast_category *cat = NULL;
+
+	if (!(dbh = find_database(database, 0))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'\n", database);
+		return NULL;
+	}
+
+	if (!table) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n");
+		release_database(dbh);
+		return NULL;
+	}
+	
+	if (!(cfg = ast_config_new())) {
+		/* If I can't alloc memory at this point, why bother doing anything else? */
+		ast_log(LOG_WARNING, "Out of memory!\n");
+		release_database(dbh);
+		return NULL;
+	}
+
+	/* Get the first parameter and first value in our list of passed paramater/value pairs */
+	newparam = va_arg(ap, const char *);
+	newval = va_arg(ap, const char *);
+	if (!newparam || !newval)  {
+		ast_log(LOG_WARNING, "MySQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
+		ast_config_destroy(cfg);
+		release_database(dbh);
+		return NULL;
+	}
+
+	initfield = ast_strdupa(newparam);
+	if (initfield && (op = strchr(initfield, ' '))) {
+		*op = '\0';
+	}
+
+	/* Must connect to the server before anything else, as the escape function requires the mysql handle. */
+	if (!mysql_reconnect(dbh)) {
+		release_database(dbh);
+		ast_config_destroy(cfg);
+		return NULL;
+	}
+
+	/* Create the first part of the query using the first parameter/value pairs we just extracted
+	   If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
+
+	if (!strchr(newparam, ' '))
+		op = " =";
+	else
+		op = "";
+
+	ESCAPE_STRING(buf, newval);
+	ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s%s '%s'", table, newparam, op, ast_str_buffer(buf));
+	while ((newparam = va_arg(ap, const char *))) {
+		newval = va_arg(ap, const char *);
+		if (!strchr(newparam, ' ')) op = " ="; else op = "";
+		ESCAPE_STRING(buf, newval);
+		ast_str_append(&sql, 0, " AND %s%s '%s'", newparam, op, ast_str_buffer(buf));
+	}
+
+	if (initfield) {
+		ast_str_append(&sql, 0, " ORDER BY %s", initfield);
+	}
+
+	va_end(ap);
+
+	ast_debug(1, "MySQL RealTime: Retrieve SQL: %s\n", ast_str_buffer(sql));
+
+	/* Execution. */
+	if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle));
+		release_database(dbh);
+		ast_config_destroy(cfg);
+		return NULL;
+	}
+
+	if ((result = mysql_store_result(&dbh->handle))) {
+		numFields = mysql_num_fields(result);
+		fields = mysql_fetch_fields(result);
+
+		while ((row = mysql_fetch_row(result))) {
+			var = NULL;
+			cat = ast_category_new("", "", -1);
+			if (!cat) {
+				ast_log(LOG_WARNING, "Out of memory!\n");
+				continue;
+			}
+			for (i = 0; i < numFields; i++) {
+				if (ast_strlen_zero(row[i]))
+					continue;
+				for (stringp = ast_strdupa(row[i]), chunk = strsep(&stringp, ";"); chunk; chunk = strsep(&stringp, ";")) {
+					if (chunk && !ast_strlen_zero(ast_strip(chunk))) {
+						if (initfield && !strcmp(initfield, fields[i].name)) {
+							ast_category_rename(cat, chunk);
+						}
+						var = ast_variable_new(fields[i].name, chunk, "");
+						ast_variable_append(cat, var);
+					}
+				}
+			}
+			ast_category_append(cfg, cat);
+		}
+	} else {
+		ast_debug(1, "MySQL RealTime: Could not find any rows in table %s.\n", table);
+	}
+
+	release_database(dbh);
+	mysql_free_result(result);
+
+	return cfg;
+}
+
+static int update_mysql(const char *database, const char *tablename, const char *keyfield, const char *lookup, va_list ap)
+{
+	struct mysql_conn *dbh;
+	my_ulonglong numrows;
+	int valsz;
+	const char *newparam, *newval;
+	struct ast_str *sql = ast_str_thread_get(&sql_buf, 100), *buf = ast_str_thread_get(&scratch_buf, 100);
+	struct tables *table;
+	struct columns *column = NULL;
+
+	if (!(dbh = find_database(database, 1))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'.\n", database);
+		return -1;
+	}
+		
+	if (!tablename) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n");
+		release_database(dbh);
+		return -1;
+	}
+
+	if (!(table = find_table(database, tablename))) {
+		ast_log(LOG_ERROR, "Table '%s' does not exist!!\n", tablename);
+		release_database(dbh);
+		return -1;
+	}
+
+	if (!(column = find_column(table, keyfield))) {
+		ast_log(LOG_ERROR, "MySQL RealTime: Updating on column '%s', but that column does not exist within the table '%s'!\n", keyfield, tablename);
+		release_table(table);
+		release_database(dbh);
+		return -1;
+	}
+
+	/* Get the first parameter and first value in our list of passed paramater/value pairs */
+	newparam = va_arg(ap, const char *);
+	newval = va_arg(ap, const char *);
+	if (!newparam || !newval)  {
+		ast_log(LOG_WARNING, "MySQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
+		release_table(table);
+		release_database(dbh);
+		return -1;
+	}
+
+	/* Check that the column exists in the table */
+	if (!(column = find_column(table, newparam))) {
+		ast_log(LOG_ERROR, "MySQL RealTime: Updating on column '%s', but that column does not exist within the table '%s'!\n", newparam, tablename);
+		release_table(table);
+		release_database(dbh);
+		return -1;
+	}
+
+	/* Must connect to the server before anything else, as the escape function requires the mysql handle. */
+	if (!mysql_reconnect(dbh)) {
+		release_table(table);
+		release_database(dbh);
+		return -1;
+	}
+
+	/* Create the first part of the query using the first parameter/value pairs we just extracted
+	   If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
+
+	ESCAPE_STRING(buf, newval);
+	ast_str_set(&sql, 0, "UPDATE %s SET %s = '%s'", tablename, newparam, ast_str_buffer(buf));
+
+	/* If the column length isn't long enough, give a chance to lengthen it. */
+	if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) {
+		internal_require(database, tablename, newparam, RQ_CHAR, valsz, SENTINEL);
+	}
+
+	while ((newparam = va_arg(ap, const char *))) {
+		newval = va_arg(ap, const char *);
+
+		/* If the column is not within the table, then skip it */
+		if (!(column = find_column(table, newparam))) {
+			ast_log(LOG_WARNING, "Attempted to update column '%s' in table '%s', but column does not exist!\n", newparam, tablename);
+			continue;
+		}
+
+		ESCAPE_STRING(buf, newval);
+		ast_str_append(&sql, 0, ", %s = '%s'", newparam, ast_str_buffer(buf));
+
+		/* If the column length isn't long enough, give a chance to lengthen it. */
+		if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) {
+			internal_require(database, tablename, newparam, RQ_CHAR, valsz, SENTINEL);
+		}
+	}
+	va_end(ap);
+
+	ESCAPE_STRING(buf, lookup);
+	ast_str_append(&sql, 0, " WHERE %s = '%s'", keyfield, ast_str_buffer(buf));
+
+	ast_debug(1, "MySQL RealTime: Update SQL: %s\n", ast_str_buffer(sql));
+
+	/* Execution. */
+	if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle));
+		release_table(table);
+		release_database(dbh);
+		return -1;
+	}
+
+	numrows = mysql_affected_rows(&dbh->handle);
+	release_table(table);
+	release_database(dbh);
+
+	ast_debug(1, "MySQL RealTime: Updated %llu rows on table: %s\n", numrows, tablename);
+
+	/* From http://dev.mysql.com/doc/mysql/en/mysql-affected-rows.html
+	 * An integer greater than zero indicates the number of rows affected
+	 * Zero indicates that no records were updated
+	 * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
+	*/
+
+	return (int)numrows;
+}
+
+static int update2_mysql(const char *database, const char *tablename, va_list ap)
+{
+	struct mysql_conn *dbh;
+	my_ulonglong numrows;
+	int first = 1;
+	const char *newparam, *newval;
+	size_t valsz;
+	struct ast_str *sql = ast_str_thread_get(&sql_buf, 100), *buf = ast_str_thread_get(&scratch_buf, 100);
+	struct ast_str *where = ast_str_thread_get(&sql2_buf, 100);
+	struct tables *table;
+	struct columns *column = NULL;
+
+	if (!tablename) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n");
+		return -1;
+	}
+
+	if (!(dbh = find_database(database, 1))) {
+		ast_log(LOG_ERROR, "Invalid database specified: %s\n", database);
+		return -1;
+	}
+
+	if (!(table = find_table(database, tablename))) {
+		ast_log(LOG_ERROR, "Table '%s' does not exist!!\n", tablename);
+		release_database(dbh);
+		return -1;
+	}
+
+	if (!sql || !buf || !where) {
+		release_database(dbh);
+		release_table(table);
+		return -1;
+	}
+
+	ast_str_set(&sql, 0, "UPDATE %s SET", tablename);
+	ast_str_set(&where, 0, "WHERE");
+
+	/* Must connect to the server before anything else, as the escape function requires the mysql handle. */
+	if (!mysql_reconnect(dbh)) {
+		release_table(table);
+		release_database(dbh);
+		return -1;
+	}
+
+	while ((newparam = va_arg(ap, const char *))) {
+		if (!(column = find_column(table, newparam))) {
+			ast_log(LOG_ERROR, "Updating on column '%s', but that column does not exist within the table '%s'!\n", newparam, tablename);
+			release_table(table);
+			release_database(dbh);
+			return -1;
+		}
+		if (!(newval = va_arg(ap, const char *))) {
+			ast_log(LOG_ERROR, "Invalid arguments: no value specified for column '%s' on '%s@%s'\n", newparam, tablename, database);
+			release_table(table);
+			release_database(dbh);
+			return -1;
+		}
+		ESCAPE_STRING(buf, newval);
+		ast_str_append(&where, 0, "%s %s='%s'", first ? "" : " AND", newparam, ast_str_buffer(buf));
+		first = 0;
+
+		/* If the column length isn't long enough, give a chance to lengthen it. */
+		if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) {
+			internal_require(database, tablename, newparam, RQ_CHAR, valsz, SENTINEL);
+		}
+	}
+
+	first = 1;
+	while ((newparam = va_arg(ap, const char *))) {
+		if (!(newval = va_arg(ap, const char *))) {
+			ast_log(LOG_ERROR, "Invalid arguments: no value specified for column '%s' on '%s@%s'\n", newparam, tablename, database);
+			release_table(table);
+			release_database(dbh);
+			return -1;
+		}
+
+		/* If the column is not within the table, then skip it */
+		if (!(column = find_column(table, newparam))) {
+			ast_log(LOG_WARNING, "Attempted to update column '%s' in table '%s', but column does not exist!\n", newparam, tablename);
+			continue;
+		}
+
+		ESCAPE_STRING(buf, newval);
+		ast_str_append(&sql, 0, "%s %s = '%s'", first ? "" : ",", newparam, ast_str_buffer(buf));
+
+		/* If the column length isn't long enough, give a chance to lengthen it. */
+		if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) {
+			internal_require(database, tablename, newparam, RQ_CHAR, valsz, SENTINEL);
+		}
+	}
+	va_end(ap);
+	release_table(table);
+
+	ast_str_append(&sql, 0, " %s", ast_str_buffer(where));
+
+	ast_debug(1, "MySQL RealTime: Update SQL: %s\n", ast_str_buffer(sql));
+
+	/* Execution. */
+	if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle));
+		release_table(table);
+		release_database(dbh);
+		return -1;
+	}
+
+	numrows = mysql_affected_rows(&dbh->handle);
+	release_database(dbh);
+
+	ast_debug(1, "MySQL RealTime: Updated %llu rows on table: %s\n", numrows, tablename);
+
+	/* From http://dev.mysql.com/doc/mysql/en/mysql-affected-rows.html
+	 * An integer greater than zero indicates the number of rows affected
+	 * Zero indicates that no records were updated
+	 * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
+	*/
+
+	return (int)numrows;
+}
+ 
+static int store_mysql(const char *database, const char *table, va_list ap)
+{
+	struct mysql_conn *dbh;
+	my_ulonglong insertid;
+	struct ast_str *sql = ast_str_thread_get(&sql_buf, 16);
+	struct ast_str *sql2 = ast_str_thread_get(&sql2_buf, 16);
+	struct ast_str *buf = ast_str_thread_get(&scratch_buf, 16);
+	int valsz;
+	const char *newparam, *newval;
+
+	if (!(dbh = find_database(database, 1))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'.\n", database);
+		return -1;
+	}
+
+	if (!table) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n");
+		release_database(dbh);
+		return -1;
+	}
+	/* Get the first parameter and first value in our list of passed paramater/value pairs */
+	newparam = va_arg(ap, const char *);
+	newval = va_arg(ap, const char *);
+	if (!newparam || !newval)  {
+		ast_log(LOG_WARNING, "MySQL RealTime: Realtime storage requires at least 1 parameter and 1 value to search on.\n");
+		release_database(dbh);
+		return -1;
+	}
+	/* Must connect to the server before anything else, as the escape function requires the mysql handle. */
+	if (!mysql_reconnect(dbh)) {
+		release_database(dbh);
+		return -1;
+	}
+	/* Create the first part of the query using the first parameter/value pairs we just extracted
+		If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
+	ESCAPE_STRING(buf, newval);
+	ast_str_set(&sql, 0, "INSERT INTO %s (%s", table, newparam);
+	ast_str_set(&sql2, 0, ") VALUES ('%s'", ast_str_buffer(buf));
+
+	internal_require(database, table, newparam, RQ_CHAR, valsz, SENTINEL);
+
+	while ((newparam = va_arg(ap, const char *))) {
+		if ((newval = va_arg(ap, const char *))) {
+			ESCAPE_STRING(buf, newval);
+		} else {
+			valsz = 0;
+			ast_str_reset(buf);
+		}
+		if (internal_require(database, table, newparam, RQ_CHAR, valsz, SENTINEL) == 0) {
+			ast_str_append(&sql, 0, ", %s", newparam);
+			ast_str_append(&sql2, 0, ", '%s'", ast_str_buffer(buf));
+		}
+	}
+	va_end(ap);
+	ast_str_append(&sql, 0, "%s)", ast_str_buffer(sql2));
+	ast_debug(1,"MySQL RealTime: Insert SQL: %s\n", ast_str_buffer(sql));
+
+	/* Execution. */
+	if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle));
+		release_database(dbh);
+		return -1;
+	}
+
+	/*!\note The return value is non-portable and may change in future versions. */
+	insertid = mysql_insert_id(&dbh->handle);
+	release_database(dbh);
+
+	ast_debug(1, "MySQL RealTime: row inserted on table: %s, id: %llu\n", table, insertid);
+
+	/* From http://dev.mysql.com/doc/mysql/en/mysql-affected-rows.html
+	 * An integer greater than zero indicates the number of rows affected
+	 * Zero indicates that no records were updated
+	 * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
+	*/
+	return (int)insertid;
+}
+
+static int destroy_mysql(const char *database, const char *table, const char *keyfield, const char *lookup, va_list ap)
+{
+	struct mysql_conn *dbh;
+	my_ulonglong numrows;
+	struct ast_str *sql = ast_str_thread_get(&sql_buf, 16);
+	struct ast_str *buf = ast_str_thread_get(&scratch_buf, 16);
+	int valsz;
+	const char *newparam, *newval;
+
+	if (!(dbh = find_database(database, 1))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'.\n", database);
+		return -1;
+	}
+
+	if (!table) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n");
+		release_database(dbh);
+		return -1;
+	}
+
+	/* Get the first parameter and first value in our list of passed paramater/value pairs */
+	/* newparam = va_arg(ap, const char *);
+	newval = va_arg(ap, const char *);*/
+	if (ast_strlen_zero(keyfield) || ast_strlen_zero(lookup))  {
+		ast_log(LOG_WARNING, "MySQL RealTime: Realtime destroying requires at least 1 parameter and 1 value to search on.\n");
+		release_database(dbh);
+		return -1;
+	}
+
+	/* Must connect to the server before anything else, as the escape function requires the mysql handle. */
+	if (!mysql_reconnect(dbh)) {
+		release_database(dbh);
+		return -1;
+	}
+
+	/* Create the first part of the query using the first parameter/value pairs we just extracted
+	   If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
+	ESCAPE_STRING(buf, lookup);
+	ast_str_set(&sql, 0, "DELETE FROM %s WHERE %s = '%s'", table, keyfield, ast_str_buffer(buf));
+	while ((newparam = va_arg(ap, const char *))) {
+		newval = va_arg(ap, const char *);
+		ESCAPE_STRING(buf, newval);
+		ast_str_append(&sql, 0, " AND %s = '%s'", newparam, ast_str_buffer(buf));
+	}
+	va_end(ap);
+
+	ast_debug(1, "MySQL RealTime: Delete SQL: %s\n", ast_str_buffer(sql));
+
+	/* Execution. */
+	if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle));
+		release_database(dbh);
+		return -1;
+	}
+
+	numrows = mysql_affected_rows(&dbh->handle);
+	release_database(dbh);
+
+	ast_debug(1, "MySQL RealTime: Deleted %llu rows on table: %s\n", numrows, table);
+
+	/* From http://dev.mysql.com/doc/mysql/en/mysql-affected-rows.html
+	 * An integer greater than zero indicates the number of rows affected
+	 * Zero indicates that no records were updated
+	 * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
+	*/
+
+	return (int)numrows;
+}
+ 
+static struct ast_config *config_mysql(const char *database, const char *table, const char *file, struct ast_config *cfg, struct ast_flags config_flags, const char *unused, const char *who_asked)
+{
+	struct mysql_conn *dbh;
+	MYSQL_RES *result;
+	MYSQL_ROW row;
+	my_ulonglong num_rows;
+	struct ast_variable *new_v;
+	struct ast_category *cur_cat = NULL;
+	struct ast_str *sql = ast_str_thread_get(&sql_buf, 200);
+	char last[80] = "";
+	int last_cat_metric = 0;
+
+	ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
+
+	if (!file || !strcmp(file, RES_CONFIG_MYSQL_CONF)) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Cannot configure myself.\n");
+		return NULL;
+	}
+
+	if (!(dbh = find_database(database, 0))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'\n", database);
+		return NULL;
+	}
+
+	ast_str_set(&sql, 0, "SELECT category, var_name, var_val, cat_metric FROM %s WHERE filename='%s' and commented=1 ORDER BY filename, cat_metric desc, var_metric asc, category, var_name, var_val, id", table, file);
+
+	ast_debug(1, "MySQL RealTime: Static SQL: %s\n", ast_str_buffer(sql));
+
+	/* We now have our complete statement; Lets connect to the server and execute it. */
+	if (!mysql_reconnect(dbh)) {
+		return NULL;
+	}
+
+	if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database. Check debug for more info.\n");
+		ast_debug(1, "MySQL RealTime: Query: %s\n", ast_str_buffer(sql));
+		ast_debug(1, "MySQL RealTime: Query Failed because: %s\n", mysql_error(&dbh->handle));
+		release_database(dbh);
+		return NULL;
+	}
+
+	if ((result = mysql_store_result(&dbh->handle))) {
+		num_rows = mysql_num_rows(result);
+		ast_debug(1, "MySQL RealTime: Found %llu rows.\n", num_rows);
+
+		/* There might exist a better way to access the column names other than counting,
+		 * but I believe that would require another loop that we don't need. */
+
+		while ((row = mysql_fetch_row(result))) {
+			if (!strcmp(row[1], "#include")) {
+				if (!ast_config_internal_load(row[2], cfg, config_flags, "", who_asked)) {
+					mysql_free_result(result);
+					release_database(dbh);
+					ast_config_destroy(cfg);
+					return NULL;
+				}
+				continue;
+			}
+
+			if (strcmp(last, row[0]) || last_cat_metric != atoi(row[3])) {
+				if (!(cur_cat = ast_category_new(row[0], "", -1))) {
+					ast_log(LOG_WARNING, "Out of memory!\n");
+					break;
+				}
+				strcpy(last, row[0]);
+				last_cat_metric = atoi(row[3]);
+				ast_category_append(cfg, cur_cat);
+			}
+			new_v = ast_variable_new(row[1], row[2], "");
+			if (cur_cat)
+				ast_variable_append(cur_cat, new_v);
+		}
+	} else {
+		ast_log(LOG_WARNING, "MySQL RealTime: Could not find config '%s' in database.\n", file);
+	}
+
+	mysql_free_result(result);
+	release_database(dbh);
+
+	return cfg;
+}
+
+static int unload_mysql(const char *database, const char *tablename)
+{
+	struct tables *cur;
+	AST_LIST_LOCK(&mysql_tables);
+	AST_LIST_TRAVERSE_SAFE_BEGIN(&mysql_tables, cur, list) {
+		if (strcmp(cur->name, tablename) == 0) {
+			AST_LIST_REMOVE_CURRENT(list);
+			destroy_table(cur);
+			break;
+		}
+	}
+	AST_LIST_TRAVERSE_SAFE_END
+	AST_LIST_UNLOCK(&mysql_tables);
+	return cur ? 0 : -1;
+}
+
+static int modify_mysql(const char *database, const char *tablename, struct columns *column, require_type type, int len)
+{
+	/*!\note Cannot use ANY of the same scratch space as is used in other functions, as this one is interspersed. */
+	struct ast_str *sql = ast_str_thread_get(&modify_buf, 100), *escbuf = ast_str_thread_get(&modify2_buf, 100);
+	struct ast_str *typestr = ast_str_thread_get(&modify3_buf, 30);
+	int waschar = strncasecmp(column->type, "char", 4) == 0 ? 1 : 0;
+	int wasvarchar = strncasecmp(column->type, "varchar", 7) == 0 ? 1 : 0;
+	int res = 0;
+	struct mysql_conn *dbh;
+
+	if (!(dbh = find_database(database, 1))) {
+		return -1;
+	}
+
+	do {
+		if (type == RQ_CHAR || waschar || wasvarchar) {
+			if (wasvarchar) {
+				ast_str_set(&typestr, 0, "VARCHAR(%d)", len);
+			} else {
+				ast_str_set(&typestr, 0, "CHAR(%d)", len);
+			}
+		} else if (type == RQ_UINTEGER1) {
+			ast_str_set(&typestr, 0, "tinyint(3) unsigned");
+		} else if (type == RQ_INTEGER1) {
+			ast_str_set(&typestr, 0, "tinyint(4)");
+		} else if (type == RQ_UINTEGER2) {
+			ast_str_set(&typestr, 0, "smallint(5) unsigned");
+		} else if (type == RQ_INTEGER2) {
+			ast_str_set(&typestr, 0, "smallint(6)");
+		} else if (type == RQ_UINTEGER3) {
+			ast_str_set(&typestr, 0, "mediumint(8) unsigned");
+		} else if (type == RQ_INTEGER3) {
+			ast_str_set(&typestr, 0, "mediumint(8)");
+		} else if (type == RQ_UINTEGER4) {
+			ast_str_set(&typestr, 0, "int(10) unsigned");
+		} else if (type == RQ_INTEGER4) {
+			ast_str_set(&typestr, 0, "int(11)");
+		} else if (type == RQ_UINTEGER8) {
+			ast_str_set(&typestr, 0, "bigint(19) unsigned");
+		} else if (type == RQ_INTEGER8) {
+			ast_str_set(&typestr, 0, "bigint(20)");
+		} else if (type == RQ_DATETIME) {
+			ast_str_set(&typestr, 0, "datetime");
+		} else if (type == RQ_DATE) {
+			ast_str_set(&typestr, 0, "date");
+		} else if (type == RQ_FLOAT) {
+			ast_str_set(&typestr, 0, "FLOAT(%d,2)", len);
+		} else {
+			ast_log(LOG_ERROR, "Unknown type (should NEVER happen)\n");
+			res = -1;
+			break;
+		}
+		ast_str_set(&sql, 0, "ALTER TABLE %s MODIFY %s %s", tablename, column->name, ast_str_buffer(typestr));
+		if (!column->null) {
+			ast_str_append(&sql, 0, " NOT NULL");
+		}
+		if (!ast_strlen_zero(column->dflt)) {
+			size_t valsz;
+			ESCAPE_STRING(escbuf, column->dflt);
+			ast_str_append(&sql, 0, " DEFAULT '%s'", ast_str_buffer(escbuf));
+		}
+
+		if (!mysql_reconnect(dbh)) {
+			ast_log(LOG_ERROR, "Unable to add column: %s\n", ast_str_buffer(sql));
+			res = -1;
+			break;
+		}
+
+		/* Execution. */
+		if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+			ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle));
+			ast_debug(1, "MySQL RealTime: Query: %s\n", ast_str_buffer(sql));
+			res = -1;
+		}
+	} while (0);
+
+	release_database(dbh);
+	return res;
+}
+
+#define PICK_WHICH_ALTER_ACTION(stringtype) \
+	if (table->database->requirements == RQ_WARN) {                                                                       \
+		ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' may not be large enough for "            \
+			"the required data length: %d (detected stringtype)\n",                                      \
+			tablename, database, column->name, size);                                                    \
+		res = -1;                                                                                        \
+	} else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) {     \
+		table_altered = 1;                                                                               \
+	} else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) {   \
+		table_altered = 1;                                                                               \
+	} else {                                                                                             \
+		res = -1;                                                                                        \
+	}
+
+static int require_mysql(const char *database, const char *tablename, va_list ap)
+{
+	struct columns *column;
+	struct tables *table = find_table(database, tablename);
+	char *elm;
+	int type, size, res = 0, table_altered = 0;
+
+	if (!table) {
+		ast_log(LOG_WARNING, "Table %s not found in database.  This table should exist if you're using realtime.\n", tablename);
+		return -1;
+	}
+
+	while ((elm = va_arg(ap, char *))) {
+		type = va_arg(ap, require_type);
+		size = va_arg(ap, int);
+		AST_LIST_TRAVERSE(&table->columns, column, list) {
+			if (strcmp(column->name, elm) == 0) {
+				/* Char can hold anything, as long as it is large enough */
+				if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) {
+					if ((size > column->len) && column->len != -1) {
+						if (table->database->requirements == RQ_WARN) {
+							ast_log(LOG_WARNING, "Realtime table %s@%s: Column '%s' should be at least %d long, but is only %d long.\n", database, tablename, column->name, size, column->len);
+							res = -1;
+						} else if (modify_mysql(database, tablename, column, type, size) == 0) {
+							table_altered = 1;
+						} else {
+							res = -1;
+						}
+					}
+				} else if (strcasestr(column->type, "unsigned")) {
+					if (!ast_rq_is_int(type)) {
+						if (table->database->requirements == RQ_WARN) {
+							ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' cannot be type '%s' (need %s)\n",
+								database, tablename, column->name, column->type,
+								type == RQ_CHAR ? "char" : type == RQ_FLOAT ? "float" :
+								type == RQ_DATETIME ? "datetime" : type == RQ_DATE ? "date" : "a rather stiff drink");
+							res = -1;
+						} else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) {
+							table_altered = 1;
+						} else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) {
+							table_altered = 1;
+						} else {
+							res = -1;
+						}
+					} else if (strncasecmp(column->type, "tinyint", 1) == 0) {
+						if (type != RQ_UINTEGER1) {
+							PICK_WHICH_ALTER_ACTION(unsigned tinyint)
+						}
+					} else if (strncasecmp(column->type, "smallint", 1) == 0) {
+						if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && type != RQ_UINTEGER2) {
+							PICK_WHICH_ALTER_ACTION(unsigned smallint)
+						}
+					} else if (strncasecmp(column->type, "mediumint", 1) == 0) {
+						if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
+							type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
+							type != RQ_UINTEGER3) {
+							PICK_WHICH_ALTER_ACTION(unsigned mediumint)
+						}
+					} else if (strncasecmp(column->type, "int", 1) == 0) {
+						if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
+							type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
+							type != RQ_UINTEGER3 && type != RQ_INTEGER3 &&
+							type != RQ_UINTEGER4) {
+							PICK_WHICH_ALTER_ACTION(unsigned int)
+						}
+					} else if (strncasecmp(column->type, "bigint", 1) == 0) {
+						if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
+							type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
+							type != RQ_UINTEGER3 && type != RQ_INTEGER3 &&
+							type != RQ_UINTEGER4 && type != RQ_INTEGER4 &&
+							type != RQ_UINTEGER8) {
+							PICK_WHICH_ALTER_ACTION(unsigned bigint)
+						}
+					}
+				} else if (strcasestr(column->type, "int")) {
+					if (!ast_rq_is_int(type)) {
+						if (table->database->requirements == RQ_WARN) {
+							ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' cannot be type '%s' (need %s)\n",
+								database, tablename, column->name, column->type,
+								type == RQ_CHAR ? "char" : type == RQ_FLOAT ? "float" :
+								type == RQ_DATETIME ? "datetime" : type == RQ_DATE ? "date" :
+								"to get a life, rather than writing silly error messages");
+							res = -1;
+						} else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) {
+							table_altered = 1;
+						} else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) {
+							table_altered = 1;
+						} else {
+							res = -1;
+						}
+					} else if (strncasecmp(column->type, "tinyint", 1) == 0) {
+						if (type != RQ_INTEGER1) {
+							PICK_WHICH_ALTER_ACTION(tinyint)
+						}
+					} else if (strncasecmp(column->type, "smallint", 1) == 0) {
+						if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && type != RQ_INTEGER2) {
+							PICK_WHICH_ALTER_ACTION(smallint)
+						}
+					} else if (strncasecmp(column->type, "mediumint", 1) == 0) {
+						if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
+							type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
+							type != RQ_INTEGER3) {
+							PICK_WHICH_ALTER_ACTION(mediumint)
+						}
+					} else if (strncasecmp(column->type, "int", 1) == 0) {
+						if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
+							type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
+							type != RQ_UINTEGER3 && type != RQ_INTEGER3 &&
+							type != RQ_INTEGER4) {
+							PICK_WHICH_ALTER_ACTION(int)
+						}
+					} else if (strncasecmp(column->type, "bigint", 1) == 0) {
+						if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
+							type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
+							type != RQ_UINTEGER3 && type != RQ_INTEGER3 &&
+							type != RQ_UINTEGER4 && type != RQ_INTEGER4 &&
+							type != RQ_INTEGER8) {
+							PICK_WHICH_ALTER_ACTION(bigint)
+						}
+					}
+				} else if (strncmp(column->type, "float", 5) == 0 && !ast_rq_is_int(type) && type != RQ_FLOAT) {
+					if (table->database->requirements == RQ_WARN) {
+						ast_log(LOG_WARNING, "Realtime table %s@%s: Column %s cannot be a %s\n", tablename, database, column->name, column->type);
+						res = -1;
+					} else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) {
+						table_altered = 1;
+					} else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) {
+						table_altered = 1;
+					} else {
+						res = -1;
+					}
+				} else if ((strncmp(column->type, "datetime", 8) == 0 || strncmp(column->type, "timestamp", 9)) && type != RQ_DATETIME) {
+					if (table->database->requirements == RQ_WARN) {
+						ast_log(LOG_WARNING, "Realtime table %s@%s: Column %s cannot be a %s\n", tablename, database, column->name, column->type);
+						res = -1;
+					} else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) {
+						table_altered = 1;
+					} else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) {
+						table_altered = 1;
+					} else {
+						res = -1;
+					}
+				} else if ((strncmp(column->type, "date", 4) == 0) && type != RQ_DATE) {
+					if (table->database->requirements == RQ_WARN) {
+						ast_log(LOG_WARNING, "Realtime table %s@%s: Column %s cannot be a %s\n", tablename, database, column->name, column->type);
+						res = -1;
+					} else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) {
+						table_altered = 1;
+					} else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) {
+						table_altered = 1;
+					} else {
+						res = -1;
+					}
+				} else { /* Other, possibly unsupported types? */
+					if (table->database->requirements == RQ_WARN) {
+						ast_log(LOG_WARNING, "Possibly unsupported column type '%s' on column '%s'\n", column->type, column->name);
+						res = -1;
+					} else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) {
+						table_altered = 1;
+					} else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) {
+						table_altered = 1;
+					} else {
+					}
+				}
+				break;
+			}
+		}
+
+		if (!column) {
+			if (table->database->requirements == RQ_WARN) {
+				ast_log(LOG_WARNING, "Table %s requires a column '%s' of size '%d', but no such column exists.\n", tablename, elm, size);
+			} else {
+				struct ast_str *sql = ast_str_thread_get(&modify_buf, 100), *fieldtype = ast_str_thread_get(&modify3_buf, 16);
+
+				if (table->database->requirements == RQ_CREATECHAR || type == RQ_CHAR) {
+					ast_str_set(&fieldtype, 0, "CHAR(%d)", size);
+				} else if (type == RQ_UINTEGER1 || type == RQ_UINTEGER2 || type == RQ_UINTEGER3 || type == RQ_UINTEGER4 || type == RQ_UINTEGER8) {
+					if (type == RQ_UINTEGER1) {
+						ast_str_set(&fieldtype, 0, "TINYINT(3) UNSIGNED");
+					} else if (type == RQ_UINTEGER2) {
+						ast_str_set(&fieldtype, 0, "SMALLINT(5) UNSIGNED");
+					} else if (type == RQ_UINTEGER3) {
+						ast_str_set(&fieldtype, 0, "MEDIUMINT(8) UNSIGNED");
+					} else if (type == RQ_UINTEGER4) {
+						ast_str_set(&fieldtype, 0, "INT(10) UNSIGNED");
+					} else if (type == RQ_UINTEGER8) {
+						ast_str_set(&fieldtype, 0, "BIGINT(20) UNSIGNED");
+					} else {
+						ast_log(LOG_WARNING, "Somebody should check this code for a rather large bug... it's about to squash Tokyo.\n");
+						continue;
+					}
+				} else if (ast_rq_is_int(type)) {
+					if (type == RQ_INTEGER1) {
+						ast_str_set(&fieldtype, 0, "TINYINT(3)");
+					} else if (type == RQ_INTEGER2) {
+						ast_str_set(&fieldtype, 0, "SMALLINT(5)");
+					} else if (type == RQ_INTEGER3) {
+						ast_str_set(&fieldtype, 0, "MEDIUMINT(8)");
+					} else if (type == RQ_INTEGER4) {
+						ast_str_set(&fieldtype, 0, "INT(10)");
+					} else if (type == RQ_INTEGER8) {
+						ast_str_set(&fieldtype, 0, "BIGINT(20)");
+					} else {
+						ast_log(LOG_WARNING, "Somebody should check this code for a rather large bug... it's about to eat Cincinnati.\n");
+						continue;
+					}
+				} else if (type == RQ_FLOAT) {
+					ast_str_set(&fieldtype, 0, "FLOAT");
+				} else if (type == RQ_DATE) {
+					ast_str_set(&fieldtype, 0, "DATE");
+				} else if (type == RQ_DATETIME) {
+					ast_str_set(&fieldtype, 0, "DATETIME");
+				} else {
+					continue;
+				}
+				ast_str_set(&sql, 0, "ALTER TABLE %s ADD COLUMN %s %s", tablename, elm, ast_str_buffer(fieldtype));
+
+				ast_mutex_lock(&table->database->lock);
+				if (!mysql_reconnect(table->database)) {
+					ast_mutex_unlock(&table->database->lock);
+					ast_log(LOG_ERROR, "Unable to add column: %s\n", ast_str_buffer(sql));
+					continue;
+				}
+
+				/* Execution. */
+				if (mysql_real_query(&table->database->handle, ast_str_buffer(sql), ast_str_strlen(sql))) {
+					ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database. Check debug for more info.\n");
+					ast_debug(1, "MySQL RealTime: Query: %s\n", ast_str_buffer(sql));
+					ast_debug(1, "MySQL RealTime: Query Failed because: %s\n", mysql_error(&table->database->handle));
+				} else {
+					table_altered = 1;
+				}
+			}
+		}
+	}
+	release_table(table);
+
+	/* If we altered the table, we must refresh the cache */
+	if (table_altered) {
+		unload_mysql(database, tablename);
+		release_table(find_table(database, tablename));
+	}
+	return res;
+}
+
+static struct ast_config_engine mysql_engine = {
+	.name = "mysql",
+	.load_func = config_mysql,
+	.realtime_func = realtime_mysql,
+	.realtime_multi_func = realtime_multi_mysql,
+	.store_func = store_mysql,
+	.destroy_func = destroy_mysql,
+	.update_func = update_mysql,
+	.update2_func = update2_mysql,
+	.require_func = require_mysql,
+	.unload_func = unload_mysql,
+};
+
+static int load_module(void)
+{
+	parse_config(0);
+
+	ast_config_engine_register(&mysql_engine);
+	if (option_verbose > 1)
+		ast_verbose(VERBOSE_PREFIX_2 "MySQL RealTime driver loaded.\n");
+	ast_cli_register_multiple(cli_realtime_mysql_status, sizeof(cli_realtime_mysql_status) / sizeof(struct ast_cli_entry));
+	return 0;
+}
+
+static int unload_module(void)
+{
+	struct mysql_conn *cur;
+	struct tables *table;
+
+	ast_cli_unregister_multiple(cli_realtime_mysql_status, sizeof(cli_realtime_mysql_status) / sizeof(struct ast_cli_entry));
+	ast_config_engine_deregister(&mysql_engine);
+	if (option_verbose > 1)
+		ast_verbose(VERBOSE_PREFIX_2 "MySQL RealTime unloaded.\n");
+
+	ast_module_user_hangup_all();
+
+	usleep(1);
+	AST_RWLIST_WRLOCK(&databases);
+	while ((cur = AST_RWLIST_REMOVE_HEAD(&databases, list))) {
+		mysql_close(&cur->handle);
+		ast_mutex_destroy(&cur->lock);
+		ast_free(cur);
+	}
+	AST_RWLIST_UNLOCK(&databases);
+
+	/* Destroy cached table info */
+	AST_LIST_LOCK(&mysql_tables);
+	while ((table = AST_LIST_REMOVE_HEAD(&mysql_tables, list))) {
+		destroy_table(table);
+	}
+	AST_LIST_UNLOCK(&mysql_tables);
+
+	return 0;
+}
+
+static int reload(void)
+{
+	parse_config(1);
+
+	if (option_verbose > 1) {
+		ast_verb(2, "MySQL RealTime reloaded.\n");
+	}
+
+	return 0;
+}
+
+static int parse_config(int reload)
+{
+	struct ast_config *config = NULL;
+	struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
+	const char *catg;
+	struct mysql_conn *cur;
+
+	if ((config = ast_config_load(RES_CONFIG_MYSQL_CONF, config_flags)) == CONFIG_STATUS_FILEMISSING) {
+		return 0;
+	} else if (config == CONFIG_STATUS_FILEUNCHANGED) {
+		return 0;
+	} else if (config == CONFIG_STATUS_FILEINVALID) {
+		ast_log(LOG_ERROR, "Not %sloading " RES_CONFIG_MYSQL_CONF "\n", reload ? "re" : "");
+	}
+
+	AST_RWLIST_WRLOCK(&databases);
+	for (catg = ast_category_browse(config, NULL); catg; catg = ast_category_browse(config, catg)) {
+		/* Does this category already exist? */
+		AST_RWLIST_TRAVERSE(&databases, cur, list) {
+			if (!strcmp(cur->unique_name, catg)) {
+				break;
+			}
+		}
+
+		if (!cur) {
+			if (!(cur = ast_calloc(1, sizeof(*cur) + strlen(catg) + 1))) {
+				ast_log(LOG_WARNING, "Could not allocate space for MySQL database '%s'\n", catg);
+				continue;
+			}
+
+			strcpy(cur->unique_name, catg); /* SAFE */
+			ast_mutex_init(&cur->lock);
+			AST_RWLIST_INSERT_TAIL(&databases, cur, list);
+		}
+
+		load_mysql_config(config, catg, cur);
+	}
+	AST_RWLIST_UNLOCK(&databases);
+
+	ast_config_destroy(config);
+
+	return 0;
+}
+
+static int load_mysql_config(struct ast_config *config, const char *category, struct mysql_conn *conn)
+{
+	const char *s;
+
+	if (!(s = ast_variable_retrieve(config, category, "dbuser"))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No database user found, using 'asterisk' as default.\n");
+		s = "asterisk";
+	}
+	ast_copy_string(conn->user, s, sizeof(conn->user));
+
+	if (!(s = ast_variable_retrieve(config, category, "dbpass"))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No database password found, using 'asterisk' as default.\n");
+		s = "asterisk";
+	}
+	ast_copy_string(conn->pass, s, sizeof(conn->pass));
+
+	if (!(s = ast_variable_retrieve(config, category, "dbhost"))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No database host found, using localhost via socket.\n");
+		s = "";
+	}
+	ast_copy_string(conn->host, s, sizeof(conn->host));
+
+	if (!(s = ast_variable_retrieve(config, category, "dbname"))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No database name found, using 'asterisk' as default.\n");
+		s = "asterisk";
+	}
+	ast_copy_string(conn->name, s, sizeof(conn->name));
+
+	if (!(s = ast_variable_retrieve(config, category, "dbport"))) {
+		ast_log(LOG_WARNING, "MySQL RealTime: No database port found, using 3306 as default.\n");
+		conn->port = 3306;
+	} else
+		conn->port = atoi(s);
+
+	if (!(s = ast_variable_retrieve(config, category, "dbsock"))) {
+		if (ast_strlen_zero(conn->host)) {
+			char *paths[3] = { "/tmp/mysql.sock", "/var/lib/mysql/mysql.sock", "/var/run/mysqld/mysqld.sock" };
+			struct stat st;
+			int i;
+			for (i = 0; i < 3; i++) {
+				if (!stat(paths[i], &st)) {
+					ast_log(LOG_WARNING, "MySQL RealTime: No database socket found, using '%s' as default.\n", paths[i]);
+					ast_copy_string(conn->sock, paths[i], sizeof(conn->sock));
+				}
+			}
+			if (i == 3) {
+				ast_log(LOG_WARNING, "MySQL RealTime: No database socket found (and unable to detect a suitable path).\n");
+				return 0;
+			}
+		}
+	} else
+		ast_copy_string(conn->sock, s, sizeof(conn->sock));
+
+	if (!(s = ast_variable_retrieve(config, category, "requirements"))) {
+		ast_log(LOG_WARNING, "MySQL realtime: no requirements setting found, using 'warn' as default.\n");
+		conn->requirements = RQ_WARN;
+	} else if (!strcasecmp(s, "createclose")) {
+		conn->requirements = RQ_CREATECLOSE;
+	} else if (!strcasecmp(s, "createchar")) {
+		conn->requirements = RQ_CREATECHAR;
+	} else if (!strcasecmp(s, "warn")) {
+		conn->requirements = RQ_WARN;
+	} else {
+		ast_log(LOG_WARNING, "MySQL realtime: unrecognized requirements setting '%s', using 'warn'\n", s);
+		conn->requirements = RQ_WARN;
+	}
+
+	if (!ast_strlen_zero(conn->host)) {
+		ast_debug(1, "MySQL RealTime host: %s\n", conn->host);
+		ast_debug(1, "MySQL RealTime port: %i\n", conn->port);
+	} else
+		ast_debug(1, "MySQL RealTime socket: %s\n", conn->sock);
+	ast_debug(1, "MySQL RealTime database name: %s\n", conn->name);
+	ast_debug(1, "MySQL RealTime user: %s\n", conn->user);
+	ast_debug(1, "MySQL RealTime password: %s\n", conn->pass);
+
+	return 1;
+}
+
+static int mysql_reconnect(struct mysql_conn *conn)
+{
+#ifdef MYSQL_OPT_RECONNECT
+	my_bool trueval = 1;
+#endif
+
+	/* mutex lock should have been locked before calling this function. */
+
+reconnect_tryagain:
+	if ((!conn->connected) && (!ast_strlen_zero(conn->host) || conn->sock) && !ast_strlen_zero(conn->user) && !ast_strlen_zero(conn->name)) {
+		if (!mysql_init(&conn->handle)) {
+			ast_log(LOG_WARNING, "MySQL RealTime: Insufficient memory to allocate MySQL resource.\n");
+			conn->connected = 0;
+			return 0;
+		}
+		if (mysql_real_connect(&conn->handle, conn->host, conn->user, conn->pass, conn->name, conn->port, conn->sock, 0)) {
+#ifdef MYSQL_OPT_RECONNECT
+			/* The default is no longer to automatically reconnect on failure,
+			 * (as of 5.0.3) so we have to set that option here. */
+			mysql_options(&conn->handle, MYSQL_OPT_RECONNECT, &trueval);
+#endif
+			ast_debug(1, "MySQL RealTime: Successfully connected to database.\n");
+			conn->connected = 1;
+			conn->connect_time = time(NULL);
+			return 1;
+		} else {
+			ast_log(LOG_ERROR, "MySQL RealTime: Failed to connect database server %s on %s (err %d). Check debug for more info.\n", conn->name, !ast_strlen_zero(conn->host) ? conn->host : conn->sock, mysql_errno(&conn->handle));
+			ast_debug(1, "MySQL RealTime: Cannot Connect (%d): %s\n", mysql_errno(&conn->handle), mysql_error(&conn->handle));
+			conn->connected = 0;
+			return 0;
+		}
+	} else {
+		/* MySQL likes to return an error, even if it reconnects successfully.
+		 * So the postman pings twice. */
+		if (mysql_ping(&conn->handle) != 0 && (usleep(1) + 2 > 0) && mysql_ping(&conn->handle) != 0) {
+			conn->connected = 0;
+			ast_log(LOG_ERROR, "MySQL RealTime: Ping failed (%d).  Trying an explicit reconnect.\n", mysql_errno(&conn->handle));
+			ast_debug(1, "MySQL RealTime: Server Error (%d): %s\n", mysql_errno(&conn->handle), mysql_error(&conn->handle));
+			goto reconnect_tryagain;
+		}
+
+		conn->connected = 1;
+		conn->connect_time = time(NULL);
+
+		if (mysql_select_db(&conn->handle, conn->name) != 0) {
+			ast_log(LOG_WARNING, "MySQL RealTime: Unable to select database: %s. Still Connected (%u) - %s.\n", conn->name, mysql_errno(&conn->handle), mysql_error(&conn->handle));
+			return 0;
+		}
+
+		ast_debug(1, "MySQL RealTime: Connection okay.\n");
+		return 1;
+	}
+}
+
+static char *handle_cli_realtime_mysql_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	struct tables *cur;
+	int l, which;
+	char *ret = NULL;
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "realtime mysql cache";
+		e->usage =
+			"Usage: realtime mysql cache [<database> <table>]\n"
+			"       Shows table cache for the MySQL RealTime driver\n";
+		return NULL;
+	case CLI_GENERATE:
+		if (a->argc < 4 || a->argc > 5) {
+			return NULL;
+		}
+		l = strlen(a->word);
+		which = 0;
+		if (a->argc == 5) {
+			AST_LIST_LOCK(&mysql_tables);
+			AST_LIST_TRAVERSE(&mysql_tables, cur, list) {
+				if (!strcasecmp(a->argv[3], cur->database->unique_name) && !strncasecmp(a->word, cur->name, l) && ++which > a->n) {
+					ret = ast_strdup(cur->name);
+					break;
+				}
+			}
+			AST_LIST_UNLOCK(&mysql_tables);
+		} else {
+			struct mysql_conn *cur;
+			AST_RWLIST_RDLOCK(&databases);
+			AST_RWLIST_TRAVERSE(&databases, cur, list) {
+				if (!strncasecmp(a->word, cur->unique_name, l) && ++which > a->n) {
+					ret = ast_strdup(cur->unique_name);
+					break;
+				}
+			}
+			AST_RWLIST_UNLOCK(&databases);
+		}
+		return ret;
+	}
+
+	if (a->argc == 3) {
+		/* List of tables */
+		AST_LIST_LOCK(&mysql_tables);
+		AST_LIST_TRAVERSE(&mysql_tables, cur, list) {
+			ast_cli(a->fd, "%20.20s %s\n", cur->database->unique_name, cur->name);
+		}
+		AST_LIST_UNLOCK(&mysql_tables);
+	} else if (a->argc == 4) {
+		int found = 0;
+		/* List of tables */
+		AST_LIST_LOCK(&mysql_tables);
+		AST_LIST_TRAVERSE(&mysql_tables, cur, list) {
+			if (!strcasecmp(cur->database->unique_name, a->argv[3])) {
+				ast_cli(a->fd, "%s\n", cur->name);
+				found = 1;
+			}
+		}
+		AST_LIST_UNLOCK(&mysql_tables);
+		if (!found) {
+			ast_cli(a->fd, "No tables cached within %s database\n", a->argv[3]);
+		}
+	} else if (a->argc == 5) {
+		/* List of columns */
+		if ((cur = find_table(a->argv[3], a->argv[4]))) {
+			struct columns *col;
+			ast_cli(a->fd, "Columns for Table Cache '%s':\n", a->argv[3]);
+			ast_cli(a->fd, "%-20.20s %-20.20s %-3.3s\n", "Name", "Type", "Len");
+			AST_LIST_TRAVERSE(&cur->columns, col, list) {
+				ast_cli(a->fd, "%-20.20s %-20.20s %3d\n", col->name, col->type, col->len);
+			}
+			ast_mutex_unlock(&cur->lock);
+		} else {
+			ast_cli(a->fd, "No such table '%s'\n", a->argv[3]);
+		}
+	}
+	return CLI_SUCCESS;
+}
+
+static char *handle_cli_realtime_mysql_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	char status[256], status2[100] = "", type[20];
+	char *ret = NULL;
+	int ctime = 0, found = 0;
+	struct mysql_conn *cur;
+	int l = 0, which = 0;
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "realtime mysql status";
+		e->usage =
+			"Usage: realtime mysql status [<database>]\n"
+			"       Shows connection information for the MySQL RealTime driver\n";
+		return NULL;
+	case CLI_GENERATE:
+		if (a->argc == 4) {
+			AST_RWLIST_RDLOCK(&databases);
+			AST_RWLIST_TRAVERSE(&databases, cur, list) {
+				if (!strncasecmp(a->word, cur->unique_name, l) && ++which > a->n) {
+					ret = ast_strdup(cur->unique_name);
+					break;
+				}
+			}
+			AST_RWLIST_UNLOCK(&databases);
+		}
+		return ret;
+	}
+
+	if (a->argc != 3)
+		return CLI_SHOWUSAGE;
+
+	AST_RWLIST_RDLOCK(&databases);
+	AST_RWLIST_TRAVERSE(&databases, cur, list) {
+		if (a->argc == 3 || (a->argc == 4 && !strcasecmp(a->argv[3], cur->unique_name))) {
+			found = 1;
+
+			if (mysql_reconnect(cur)) {
+				snprintf(type, sizeof(type), "connected to");
+				ctime = time(NULL) - cur->connect_time;
+			} else {
+				snprintf(type, sizeof(type), "configured for");
+				ctime = -1;
+			}
+
+			if (!ast_strlen_zero(cur->host)) {
+				snprintf(status, sizeof(status), "%s %s %s@%s, port %d", cur->unique_name, type, cur->name, cur->host, cur->port);
+			} else {
+				snprintf(status, sizeof(status), "%s %s %s on socket file %s", cur->unique_name, type, cur->name, cur->sock);
+			}
+
+			if (!ast_strlen_zero(cur->user)) {
+				snprintf(status2, sizeof(status2), " with username %s", cur->user);
+			} else {
+				status2[0] = '\0';
+			}
+
+			if (ctime > 31536000) {
+				ast_cli(a->fd, "%s%s for %.1f years.\n", status, status2, (double)ctime / 31536000.0);
+			} else if (ctime > 86400 * 30) {
+				ast_cli(a->fd, "%s%s for %d days.\n", status, status2, ctime / 86400);
+			} else if (ctime > 86400) {
+				ast_cli(a->fd, "%s%s for %d days, %d hours.\n", status, status2, ctime / 86400, (ctime % 86400) / 3600);
+			} else if (ctime > 3600) {
+				ast_cli(a->fd, "%s%s for %d hours, %d minutes.\n", status, status2, ctime / 3600, (ctime % 3600) / 60);
+			} else if (ctime > 60) {
+				ast_cli(a->fd, "%s%s for %d minutes.\n", status, status2, ctime / 60);
+			} else if (ctime > -1) {
+				ast_cli(a->fd, "%s%s for %d seconds.\n", status, status2, ctime);
+			} else {
+				ast_cli(a->fd, "%s%s.\n", status, status2);
+			}
+		}
+	}
+	AST_RWLIST_UNLOCK(&databases);
+
+	if (!found) {
+		ast_cli(a->fd, "No connections configured.\n");
+	}
+	return CLI_SUCCESS;
+}
+
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "MySQL RealTime Configuration Driver",
+		.load = load_module,
+		.unload = unload_module,
+		.reload = reload,
+		);
+