rvwpconfig.c

基于h323协议的软phone

			}
			ADDITEM(ras->registrationInfo->endpointVendor, productId, rasLevel+3, 1);
			ADDITEM(ras->registrationInfo->endpointVendor, versionId, rasLevel+3, 1);
		}
	}

	if (ras->rasMulticastAddress != NULL)
	{
		addItem(rasLevel+1, 0, (RvInt32)&tmpval, 0, "rasMulticastAddress");

		addItem(rasLevel+2, 0, (RvInt32)&tmpval, 0, "ipAddress");

		addItem(rasLevel+3, 0, ras->rasMulticastAddress->ipAddress.ip, 0, "ip");
		addItem(rasLevel+3, 0, ras->rasMulticastAddress->ipAddress.port, 0, "port");
	}

	if (ras->alternateTransportAddresses != NULL)
	{
		/*annexE used, add when necessary*/
	}

	return 0;
}

int buildQ931Cof(IN Q931Configuration* q931)
{
	int q931Level = 1;
	addItem(q931Level, 0, 0, 0, "Q931");

	ADDITEM(q931, responseTimeOut, q931Level+1, 0);
	ADDITEM(q931, connectTimeOut, q931Level+1, 0);
	ADDITEM(q931, callSignalingPort, q931Level+1, 0);
	ADDITEM(q931, annexEcallSignalingPort, q931Level+1, 0);
	ADDITEM(q931, maxCalls, q931Level+1, 0);
	ADDITEM(q931, manualAccept, q931Level+1, 0);
	ADDITEM(q931, notEstablishControl, q931Level+1, 0);
	ADDITEM(q931, h245Tunneling, q931Level+1, 0);
	ADDITEM(q931, earlyH245, q931Level+1, 0);
	ADDITEM(q931, autoAnswer, q931Level+1, 0);
	ADDITEM(q931, manualCallProceeding, q931Level+1, 0);
	ADDITEM(q931, overlappedSending, q931Level+1, 0);
	ADDITEM(q931, t302, q931Level+1, 0);
	ADDITEM(q931, t304, q931Level+1, 0);
	ADDITEM(q931, busyCause, q931Level+1, 0);
	ADDITEM(q931, busyReason, q931Level+1, 0);
	ADDITEM(q931, diffSrcAddressInSetupAndARQ, q931Level+1, 0);
	ADDITEM(q931, postControlDisconnectionDelay, q931Level+1, 0);
	ADDITEM(q931, keepCallOnQ931Close, q931Level+1, 0);

	if (q931->useAnnexE != NULL)
	{
		/*annexE used, add when necessary*/
	}

	return 0;
}

int buildmpc(int level, MultipointCapability* mpc)
{
int i;
char tmpbuf[32];
int tmpval=0;

	addItem(level, 0, (RvInt32)&mpc->multicastCapability, 0, "multicastCapability");
	addItem(level, 0, (RvInt32)&mpc->multiUniCastConference, 0, "multiUniCastConference");

	if (mpc->mediaDistributionCapability != NULL)
	{
		addItem(level, 0, (RvInt32)&tmpval, 0, "mediaDistributionCapability");
	}
	for (i = 0; i < mpc->size; i++)
	{
		sprintf(tmpbuf, "%d", i+1);
		addItem(level+1, 0, (RvInt32)&tmpval, strlen(tmpbuf), tmpbuf);

		addItem(level+2, 0, (RvInt32)&mpc->mediaDistributionCapability[i].centralizedControl, 0, "centralizedControl");
		addItem(level+2, 0, (RvInt32)&mpc->mediaDistributionCapability[i].distributedControl, 0, "distributedControl");
		addItem(level+2, 0, (RvInt32)&mpc->mediaDistributionCapability[i].centralizedAudio, 0, "centralizedAudio");
		addItem(level+2, 0, (RvInt32)&mpc->mediaDistributionCapability[i].distributedAudio, 0, "distributedAudio");
		addItem(level+2, 0, (RvInt32)&mpc->mediaDistributionCapability[i].centralizedVideo, 0, "centralizedVideo");
		addItem(level+2, 0, (RvInt32)&mpc->mediaDistributionCapability[i].distributedVideo, 0, "distributedVideo");
	}
return 0;
}

int 	buildct(int level, int size, CapabilityTableEntry* ct)
{
int i, tmpval=0;
char tmpbuf[32];
	if (ct != NULL)
	{
		addItem(level, 0, (RvInt32)&tmpval, 0, "capabilityTable");
	}
	for (i = 0; i < size; i++)
	{
		CapabilityTableEntry tt = ct[i];
		AudioCapability*	ta = &ct[i].capability.receiveAudioCapability;
		
		sprintf(tmpbuf, "%d", i+1);
		addItem(level+1, 0, (RvInt32)&tmpval, strlen(tmpbuf), tmpbuf);

		addItem(level+2, 0, (RvInt32)&tt.capabilityTableEntryNumber, 0, "capabilityTableEntryNumber");
		addItem(level+2, 0, (RvInt32)&tmpval, 0, "capability") ;

		addItem(level+3, 0, (RvInt32)&tmpval, 0, "receiveAudioCapability");

		ADDITEM(ta, g711Alaw64k, level+4, 0);
		ADDITEM(ta, g711Alaw56k, level+4, 0);
		ADDITEM(ta, g711Ulaw64k, level+4, 0);
		ADDITEM(ta, g711Ulaw56k, level+4, 0);
		ADDITEM(ta, g729, level+4, 0);
		ADDITEM(ta, g729AnnexA, level+4, 0);
		ADDITEM(ta, g729wAnnexB, level+4, 0);
		ADDITEM(ta, g729AnnexAwAnnexB, level+4, 0);
		if (ta->g722_64k != NULL)
			addItem(level+4, 0, (RvInt32)ta->g722_64k, 0, "g722-64k");
		if (ta->g722_56k != NULL)
			addItem(level+4, 0, (RvInt32)ta->g722_56k, 0, "g722-56k");
		if (ta->g722_48k != NULL)
			addItem(level+4, 0, (RvInt32)ta->g722_48k, 0, "g722-48k");
		if (ta->g7231 != NULL)
		{
			addItem(level+4, 0, (RvInt32)&tmpval, 0, "g7231");
			addItem(level+5, 0, (RvInt32)&ta->g7231->maxAl_sduAudioFrames, 0, "maxAl-sduAudioFrames");
			addItem(level+5, 0, (RvInt32)&ta->g7231->silenceSuppression, 0, "silenceSuppression");
		}
	}
return 0;
}

int 	buildcd(int level, int size, CapabilityDescriptor* cd)
{
int i, j, k, tmpval=0;
char tmpbuf[32];
	if (cd != NULL)
	{
		addItem(level, 0, (RvInt32)&tmpval, 0, "capabilityDescriptors");
	}

	for (i = 0; i < size; i++)
	{
		CapabilityDescriptor* tt = &cd[i];
		sprintf(tmpbuf, "%d", i+1);
		addItem(level+1, 0, (RvInt32)&tmpval, strlen(tmpbuf), tmpbuf);

		addItem(level+2, 0, (RvInt32)&tt->capabilityDescriptorNumber, 0, "capabilityDescriptorNumber");

		if (tt->simultaneousCapabilities != NULL)
		{
			addItem(level+2, 0, 0, 0, "simultaneousCapabilities");
		}
		for (j = 0; j < tt->size; j++)
		{
			sprintf(tmpbuf, "%d", j+1);
			addItem(level+3, 0, (RvInt32)&tmpval, strlen(tmpbuf), tmpbuf);

			for (k = 0; k < tt->simultaneousCapabilities[j].size; k++)
			{
				sprintf(tmpbuf, "%d", k+1);
				addItem(level+4, 0, (RvInt32)&tt->simultaneousCapabilities[j].val[k], strlen(tmpbuf), tmpbuf);
			}
		}
/*		*/
	}
return 0;
}

int buildTermSetCfg(int level, TermianlCapabilitySet* termSet)
{
	int  tmpval=0;
/*	char tmpbuf[32];*/
	addItem(level, 0, (RvInt32)&tmpval, 0, "terminalCapabilitySet");

	addItem(level+1, 0, (RvInt32)&termSet->sequenceNumber, 0, "sequenceNumber");
	addItem(level+1, 0, (RvInt32)&termSet->protocolIdentifier, 0, "protocolIdentifier");

	if (termSet->multiplexCapability != NULL)
	{
		addItem(level+1, 0, (RvInt32)&tmpval, 0, "multiplexCapability");

		addItem(level+2, 0, (RvInt32)&tmpval, 0, "h2250Capability");
		{
		H2250Capability*	tt = &termSet->multiplexCapability->h2250Capability;
			addItem(level+3, 0, (RvInt32)&tt->maximumAudioDelayJitter, 0, "maximumAudioDelayJitter");
			addItem(level+3, 0, (RvInt32)&tt->rtcpVideoControlCapability, 0, "rtcpVideoControlCapability");
			addItem(level+3, 0, (RvInt32)&tmpval, 0, "mediaPacketizationCapability");
			addItem(level+4, 0, (RvInt32)&tt->mediaPacketizationCapability.h261aVideoPacketization, 0, "h261aVideoPacketization");

			if (tt->receiveMultipointCapability != NULL)
			{
				addItem(level+3, 0, (RvInt32)&tmpval, 0, "receiveMultipointCapability");

				buildmpc(level+4, tt->receiveMultipointCapability);
			}
			if (tt->transmitMultipointCapability != NULL)
			{
				addItem(level+3, 0, (RvInt32)&tmpval, 0, "transmitMultipointCapability");

				buildmpc(level+4, tt->transmitMultipointCapability);
			}
			if (tt->receiveAndTransmitMultipointCapability!= NULL)
			{
				addItem(level+3, 0, (RvInt32)&tmpval, 0, "receiveAndTransmitMultipointCapability");

				buildmpc(level+4, tt->receiveAndTransmitMultipointCapability);
			}

			addItem(level+3, 0, (RvInt32)&tmpval, 0, "mcCapability");
			addItem(level+4, 0, (RvInt32)&tt->mcCapability.centralizedConferenceMC, 0, "centralizedConferenceMC");
			addItem(level+4, 0, (RvInt32)&tt->mcCapability.decentralizedConferenceMC, 0, "decentralizedConferenceMC");

		}
	}

	buildct(level+1, termSet->tableSize,  termSet->capabilityTable);
	buildcd(level+1, termSet->descSize, termSet->capabilityDescriptor);
/**/
return 0;
}

int buildH245Cof(IN H245Configuration* h245)
{
int i, tmpval=0;
char tmpbuf[32];
	int h245Level = 1;
	addItem(h245Level, 0, (RvInt32)&tmpval, 0, "h245");

	ADDITEM(h245, channelsTimeout, h245Level+1, 0);
	ADDITEM(h245, roundTripTimeout, h245Level+1, 0);
	ADDITEM(h245, requestCloseTimeout, h245Level+1, 0);
	ADDITEM(h245, requestModeTimeout, h245Level+1, 0);
	ADDITEM(h245, mediaLoopTimeout, h245Level+1, 0);

	if (h245->masterSlave != NULL)
	{
		addItem(h245Level+1, 0, (RvInt32)&tmpval, 0, "masterSlave");

		ADDITEM(h245->masterSlave, terminalType, h245Level+2, 0);
		ADDITEM(h245->masterSlave, manulOperation, h245Level+2, 0);
		ADDITEM(h245->masterSlave, manualResponse, h245Level+2, 0);
		ADDITEM(h245->masterSlave, timeout, h245Level+2, 0);
	}

	if (h245->capabilities != NULL)
	{
		/* add when necessary
		TermianlCapabilitySet*	terminalCapabilitySet;
		*/
		addItem(h245Level+1, 0, (RvInt32)&tmpval, 0, "capabilities");

		ADDITEM(h245->capabilities, manualOperation, h245Level+2, 0);
		ADDITEM(h245->capabilities, manualReqponse, h245Level+2, 0);
		ADDITEM(h245->capabilities, timeout, h245Level+2, 0);
		if (h245->capabilities->terminalCapabilitySet != 0)
		{
			buildTermSetCfg(h245Level+2, h245->capabilities->terminalCapabilitySet);
		}
	}

	if (h245->channels != NULL)
	{
		addItem(h245Level+1, 0, 0, strlen("channels"), "channels");

		for (i = 0; i < h245->channelsSize; i++)
		{
			sprintf(tmpbuf, "%d", i+1);
			addItem(h245Level+2, 0, (RvInt32)&tmpval, strlen(tmpbuf), tmpbuf);

			addItem(h245Level+3, 1, (RvInt32)h245->channels[i].name, strlen(h245->channels[i].name), "name");

			addItem(h245Level+3, 0, (RvInt32)&tmpval, 0, "dataType");
			addItem(h245Level+4, 0, (RvInt32)&tmpval, 0, "audioData");

			ADDITEM(h245->channels[i].dataType.audioData, g711Alaw64k, h245Level+5, 0);
			ADDITEM(h245->channels[i].dataType.audioData, g711Alaw56k, h245Level+5, 0);
			ADDITEM(h245->channels[i].dataType.audioData, g711Ulaw64k, h245Level+5, 0);
			ADDITEM(h245->channels[i].dataType.audioData, g711Ulaw56k, h245Level+5, 0);
			ADDITEM(h245->channels[i].dataType.audioData, g729, h245Level+5, 0);
			ADDITEM(h245->channels[i].dataType.audioData, g729AnnexA, h245Level+5, 0);
			ADDITEM(h245->channels[i].dataType.audioData, g729wAnnexB, h245Level+5, 0);
			ADDITEM(h245->channels[i].dataType.audioData, g729AnnexAwAnnexB, h245Level+5, 0);
			if (h245->channels[i].dataType.audioData->g722_64k != NULL)
				addItem(h245Level+5, 0, (RvInt32)h245->channels[i].dataType.audioData->g722_64k, 0, "g722-64k");
			if (h245->channels[i].dataType.audioData->g722_56k != NULL)
				addItem(h245Level+5, 0, (RvInt32)h245->channels[i].dataType.audioData->g722_56k, 0, "g722-56k");
			if (h245->channels[i].dataType.audioData->g722_48k != NULL)
				addItem(h245Level+5, 0, (RvInt32)h245->channels[i].dataType.audioData->g722_48k, 0, "g722-48k");
			if (h245->channels[i].dataType.audioData->g7231 != NULL)
			{
				addItem(h245Level+5, 0, (RvInt32)&tmpval, 0, "g7231");
				addItem(h245Level+6, 0, (RvInt32)&h245->channels[i].dataType.audioData->g7231->maxAl_sduAudioFrames, 0, "maxAl-sduAudioFrames");
				addItem(h245Level+6, 0, (RvInt32)&h245->channels[i].dataType.audioData->g7231->silenceSuppression, 0, "silenceSuppression");
			}
		}
	}

	/*add when necessary
	   addItem(h245Level+1, 0, 0, strlen("ModeEntry"), "ModeEntry");
	*/

return 0;
}

int buildConfigRVStack(IN Config* config)
{
	int iRet;

	if (config == NULL)
		return ERROR;

	iRet = prePareConfig();
	if (iRet < 0) return iRet;

	if (config->system != NULL)
	{
		iRet = buildSysCof(config->system);
		if (iRet < 0) return iRet;
	}

	if (config->RAS != NULL)
	{
		iRet = buildRasCof(config->RAS);
		if (iRet < 0) return iRet;
	}

	if (config->Q931 != NULL)
	{
		iRet = buildQ931Cof(config->Q931);
		if (iRet < 0) return iRet;
	}

/*taskDelay(10*100);*/
	if (config->h245 != NULL)
	{
		iRet = buildH245Cof(config->h245);
		if (iRet < 0) return iRet;
	}

	iRet = bufCfOffset - 20;
	/*buf size*/
	(*(RvUint32 *)(bufConfig + 8)) = RvConvertHostToNetwork32(iRet);
	/*buf nodes*/
	(*(RvUint32 *)(bufConfig + 12)) = RvConvertHostToNetwork32(bufCfNode);
	/*str size*/
	(*(RvUint32 *)(bufConfig + 16)) = RvConvertHostToNetwork32(iRet);

	return 0;
}