rvmegacoencode.c

h.248协议源码

			rvMegacoSignalEncode(rvMegacoSignalsDescriptorGetSignal(x, i), os);
			sep = opt->format->comma;
		}		
		rvStrStreamPut(os, '}');
	}
}

static void rvMegacoObservedEventEncode(const RvMegacoObservedEvent *x, RvStrStream *os)
{
	const RvTimeStamp *ts = rvMegacoObservedEventGetTimeStamp(x);
	if(rvTimeStampIsSet(ts))
	{
		rvTimeStampEncode(ts, os);
		rvStrStreamPut(os, ':');
	}
	rvMegacoEventEncode(&x->event, os);
}

static void rvMegacoObservedEventsDescriptorEncode(const RvMegacoObservedEventsDescriptor *x, RvStrStream *os)
{
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	rvStrStreamWriteStr(os, opt->compact ? "OE" : "ObservedEvents");
	if(rvMegacoObservedEventsDescriptorIsSet(x))
	{
		size_t i;
		rvStrStreamPut(os, '=');
		rvStrStreamWriteUInt(os, rvMegacoObservedEventsDescriptorGetRequestId(x));
		rvStrStreamPut(os, '{');
		for(i=0; i<rvMegacoObservedEventsDescriptorGetNumEvents(x); ++i)
		{
			if(i) rvStrStreamWriteStr(os, opt->format->comma);
			rvMegacoObservedEventEncode(rvMegacoObservedEventsDescriptorGetEvent(x, i), os);
		}
		rvStrStreamPut(os, '}');
	}
}

static void rvMegacoEventsDescriptorEncode(const RvMegacoEventsDescriptor *x, RvStrStream *os);

static void rvMegacoRequestedEventEncode(const RvMegacoRequestedEvent *x, RvStrStream *os)
{
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	unsigned int streamId = rvMegacoRequestedEventGetStreamId(x);
	const RvMegacoSignalsDescriptor *signals = rvMegacoRequestedEventGetEmbSignals(x);
	const RvMegacoEventsDescriptor *events = rvMegacoRequestedEventGetEmbEvents(x);
	const RvMegacoDigitMapDescriptor *digitMap = rvMegacoRequestedEventGetEmbDigitMap(x);
	const RvMegacoParameterList *params = rvMegacoRequestedEventGetParameterList(x);
	const char *sep = "{";

	rvMegacoPackageItemEncode(rvMegacoRequestedEventGetName(x), os);
	if(streamId)
	{
		rvStrStreamWriteStr(os, sep);
		rvStrStreamWriteStr(os, opt->compact ? "ST=" : "Stream=");
		rvStrStreamWriteUInt(os, streamId);
		sep = opt->format->comma;
	}
	if(rvMegacoSignalsDescriptorIsSet(signals) || rvMegacoEventsDescriptorIsSet(events))
	{
		const char *sep2 = nullStr;
		rvStrStreamWriteStr(os, sep);
		rvStrStreamWriteStr(os, opt->compact ? "EM{" : "Embed{");
		if(rvMegacoSignalsDescriptorIsSet(signals))
			rvMegacoSignalsDescriptorEncode(signals, os), sep2 = opt->format->comma;
		if(rvMegacoEventsDescriptorIsSet(events))
		{
			rvStrStreamWriteStr(os, sep2);
			rvMegacoEventsDescriptorEncode(events, os);
		}
		rvStrStreamPut(os, '}');
		sep = opt->format->comma;
	}
	if(rvMegacoDigitMapDescriptorIsSet(digitMap))
	{
		/* embedded digit map has different syntax --
		   do not call rvMegacoDigitMapDescriptorEncode! */
		const RvMegacoDigitMap *dm = rvMegacoDigitMapDescriptorGetDigitMap(digitMap);
		rvStrStreamWriteStr(os, sep);
		rvStrStreamWriteStr(os, opt->compact ? "DM" : "DigitMap");
		if(rvMegacoDigitMapGetSize(dm))
		{
			rvStrStreamPut(os, '{');
			rvMegacoDigitMapEncode(dm, os);
			rvStrStreamPut(os, '}');
		}
		else
		{
			rvStrStreamPut(os, '=');
			rvStrStreamWriteStr(os, rvMegacoDigitMapDescriptorGetName(digitMap));
		}
		sep = opt->format->comma;
	}
	if(rvMegacoRequestedEventGetKeepActiveFlag(x))
	{
		rvStrStreamWriteStr(os, sep);
		rvStrStreamWriteStr(os, opt->compact ? "KA" : "KeepActive");
		sep = opt->format->comma;
	}
	if(!rvMegacoParameterListIsEmpty(params))
	{
		rvStrStreamWriteStr(os, sep);
		rvMegacoParameterListEncode(params, os);
		sep = opt->format->comma;
	}
	if(sep == opt->format->comma)
	{
		rvStrStreamPut(os, '}');
	}
}

static void rvMegacoEventsDescriptorEncode(const RvMegacoEventsDescriptor *x, RvStrStream *os)
{
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	rvStrStreamWriteStr(os, opt->compact ? "E" : "Events");
	if(rvMegacoEventsDescriptorIsSet(x))
	{
		size_t i;
		rvStrStreamPut(os, '=');
		rvStrStreamWriteUInt(os, rvMegacoEventsDescriptorGetRequestId(x));
		rvStrStreamPut(os, '{');
		for(i=0; i<rvMegacoEventsDescriptorGetNumEvents(x); ++i)
		{
			if(i) rvStrStreamWriteStr(os, opt->format->comma);
			rvMegacoRequestedEventEncode(rvMegacoEventsDescriptorGetEvent(x, i), os);
		}
		rvStrStreamPut(os, '}');
	}
}

static void rvMegacoTerminationStateDescriptorEncode(const RvMegacoTerminationStateDescriptor *x, RvStrStream *os)
{
	RvMegacoServiceState state = rvMegacoTerminationStateDescriptorGetServiceState(x);
	const RvMegacoParameterList *params = rvMegacoTerminationStateDescriptorGetParameterList(x);
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	const char *sep = opt->compact ? "TS{" : "TerminationState{";

	if(state != rvMegacoServiceStateDefault)
	{
		rvStrStreamWriteStr(os, sep);
		rvStrStreamWriteStr(os, opt->compact ? "SI=" : "ServiceStates=");
		switch(state)
		{
		case RV_MEGACOSERVICESTATE_TEST:
			rvStrStreamWriteStr(os, opt->compact ? "TE" : "Test");
			break;
		case RV_MEGACOSERVICESTATE_OUTOFSERVICE:
			rvStrStreamWriteStr(os, opt->compact ? "OS" : "OutOfService");
			break;
		case RV_MEGACOSERVICESTATE_INSERVICE:
			rvStrStreamWriteStr(os, opt->compact ? "IV" : "InService");
			break;
		default:
			rvStrStreamSetErrorStatus(os, RV_MEGACOENCODEERROR_CORRUPTOBJECT);
			break;
		}
		sep = opt->format->comma;
	}
	if(rvMegacoTerminationStateDescriptorIsLockstepMode(x))
	{
		rvStrStreamWriteStr(os, sep);
		rvStrStreamWriteStr(os, opt->compact ? "BF=SP" : "Buffer=LockStep");
		sep = opt->format->comma;
	}
	if(!rvMegacoParameterListIsEmpty(params))
	{
		rvStrStreamWriteStr(os, sep);
		rvMegacoParameterListEncode(params, os);
		sep = opt->format->comma;
	}
	if(sep == opt->format->comma)
	{
		rvStrStreamPut(os, '}');
	}
}

static void escapeRightBraces(RvStrStream *os, const char *s)
{
	while(*s)
	{
		if(*s == '}')
			rvStrStreamWriteStr(os, "\\}");
		else
			rvStrStreamPut(os, *s);
		++s;
	}
}

static void rvMegacoStreamDescriptorEncode(const RvMegacoStreamDescriptor *x, RvStrStream *os)
{
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	unsigned int id = rvMegacoStreamDescriptorGetId(x);
	RvMegacoStreamMode mode = rvMegacoStreamDescriptorGetMode(x);
	const RvMegacoParameterList *params = rvMegacoStreamDescriptorGetParameterList(x);
	const char *sep = nullStr;

	if(id != rvMegacoStreamIdDefault)
	{
		rvStrStreamWriteStr(os, opt->compact ? "ST=" : "Stream=");
		rvStrStreamWriteUInt(os, id);
		rvStrStreamPut(os, '{');
	}
	if(rvMegacoStreamDescriptorIsLocalDescriptorSet(x))
	{
		size_t i;
		rvStrStreamWriteStr(os, opt->compact ? "L{\n" : "Local{\n");
		for(i=0; i<rvMegacoStreamDescriptorGetNumLocalDescriptors(x); ++i)
		{
			RvStrStream sdpOs;
			rvStrStreamConstruct(&sdpOs, 2048, rvStrStreamGetAllocator(os));
			rvSdpMsgEncode((RvSdpMsg *)rvMegacoStreamDescriptorGetLocalDescriptor(x, i), &sdpOs);
			escapeRightBraces(os, rvStrStreamGetStr(&sdpOs));
			rvStrStreamDestruct(&sdpOs);
		}
		rvStrStreamPut(os, '}');
		sep = opt->format->comma;
	}
	if(rvMegacoStreamDescriptorIsRemoteDescriptorSet(x))
	{
		size_t i;
		rvStrStreamWriteStr(os, sep);
		rvStrStreamWriteStr(os, opt->compact ? "R{\n" : "Remote{\n");
		for(i=0; i<rvMegacoStreamDescriptorGetNumRemoteDescriptors(x); ++i)
		{
			RvStrStream sdpOs;
			rvStrStreamConstruct(&sdpOs, 2048, rvStrStreamGetAllocator(os));
			rvSdpMsgEncode((RvSdpMsg *)rvMegacoStreamDescriptorGetRemoteDescriptor(x, i), &sdpOs);
			escapeRightBraces(os, rvStrStreamGetStr(&sdpOs));
			rvStrStreamDestruct(&sdpOs);
		}
		rvStrStreamPut(os, '}');
		sep = opt->format->comma;
	}
	if(mode != RV_MEGACOSTREAMMODE_NOTSET ||
		rvMegacoStreamDescriptorGetReserveValueMode(x) ||
		rvMegacoStreamDescriptorGetReserveGroupMode(x) ||
		!rvMegacoParameterListIsEmpty(params))
	{
		const char *sep2 = nullStr;
		rvStrStreamWriteStr(os, sep);
		rvStrStreamWriteStr(os, opt->compact ? "O{" : "LocalControl{");
		if(mode != RV_MEGACOSTREAMMODE_NOTSET)
		{
			rvStrStreamWriteStr(os, opt->compact ? "MO=" : "Mode=");
			switch(mode)
			{
			case RV_MEGACOSTREAMMODE_INACTIVE:
				rvStrStreamWriteStr(os, opt->compact ? "IN" : "Inactive");
				break;
			case RV_MEGACOSTREAMMODE_SENDONLY:
				rvStrStreamWriteStr(os, opt->compact ? "SO" : "SendOnly");
				break;
			case RV_MEGACOSTREAMMODE_RECVONLY:
				rvStrStreamWriteStr(os, opt->compact ? "RC" : "ReceiveOnly");
				break;
			case RV_MEGACOSTREAMMODE_SENDRECV:
				rvStrStreamWriteStr(os, opt->compact ? "SR" : "SendReceive");
				break;
			case RV_MEGACOSTREAMMODE_LOOPBACK:
				rvStrStreamWriteStr(os, opt->compact ? "LB" : "Loopback");
				break;
			default: 
				rvStrStreamSetErrorStatus(os, RV_MEGACOENCODEERROR_CORRUPTOBJECT);
			}
			sep2 = opt->format->comma;
		}
		if(rvMegacoStreamDescriptorGetReserveValueMode(x))
		{
			rvStrStreamWriteStr(os, sep2);
			rvStrStreamWriteStr(os, opt->compact ? "RV=ON" : "ReservedValue=ON");
			sep2 = opt->format->comma;
		}
		if(rvMegacoStreamDescriptorGetReserveGroupMode(x))
		{
			rvStrStreamWriteStr(os, sep2);
			rvStrStreamWriteStr(os, opt->compact ? "RG=ON" : "ReservedGroup=ON");
			sep2 = opt->format->comma;
		}
		if(!rvMegacoParameterListIsEmpty(params))
		{
			rvStrStreamWriteStr(os, sep2);
			rvMegacoParameterListEncode(params, os);
		}
		rvStrStreamPut(os, '}');
	}
	if(id != rvMegacoStreamIdDefault)
		rvStrStreamPut(os, '}');
}

static void rvMegacoMediaDescriptorEncode(const RvMegacoMediaDescriptor *x, RvStrStream *os)
{
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	rvStrStreamWriteStr(os, opt->compact ? "M" : "Media");
	if(rvMegacoMediaDescriptorIsSet(x))
	{
		const RvMegacoTerminationStateDescriptor *ts = rvMegacoMediaDescriptorGetTerminationState(x);
		const char *sep = opt->format->brace0;
		size_t i;
		for(i=0; i<rvMegacoMediaDescriptorGetNumStreams(x); ++i)
		{
			const RvMegacoStreamDescriptor *stream = rvMegacoMediaDescriptorGetStream(x, i);
			if(rvMegacoStreamDescriptorIsSet(stream))
			{
				rvStrStreamWriteStr(os, sep);
				rvMegacoStreamDescriptorEncode(stream, os);
				sep = opt->format->comma0;
			}
		}
		if(rvMegacoTerminationStateDescriptorIsSet(ts))
		{
			rvStrStreamWriteStr(os, sep);
			rvMegacoTerminationStateDescriptorEncode(ts, os);
		}
		rvStrStreamWriteStr(os, opt->format->indent3);
		rvStrStreamPut(os, '}');
	}
}

static RvBool rvMegacoModemDescriptorHasMultipleTypes(const RvMegacoModemDescriptor *x)
{
	size_t n = rvMegacoModemDescriptorGetNumOtherTypes(x);
	unsigned int types = rvMegacoModemDescriptorGetTypes(x);
	for(;;)
	{
		if(n >= 2)
			return rvTrue;
		if(types == 0)
			return rvFalse;
		if(types & 1)
			++n;
		types >>= 1;
	}
}

static void rvMegacoModemDescriptorEncode(const RvMegacoModemDescriptor *x, RvStrStream *os)
{
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	rvStrStreamWriteStr(os, opt->compact ? "MD" : "Modem");
	if(rvMegacoModemDescriptorIsSet(x))
	{
		RvMegacoModemType types = rvMegacoModemDescriptorGetTypes(x);
		const RvMegacoParameterList *params = rvMegacoModemDescriptorGetParameterList(x);
		RvBool multiple = rvMegacoModemDescriptorHasMultipleTypes(x);
		const char *sep = nullStr;
		size_t i;

		rvStrStreamPut(os, (char)(multiple ? '[' : '='));
		if(types & RV_MEGACOMODEMTYPE_V32BIS)
			rvStrStreamWriteStr(os, "V32b"), sep = opt->format->comma;
		if(types & RV_MEGACOMODEMTYPE_V22BIS)
			rvStrStreamWriteStr(os, sep), rvStrStreamWriteStr(os, "V22b"), sep = opt->format->comma;
		if(types & RV_MEGACOMODEMTYPE_V18)
			rvStrStreamWriteStr(os, sep), rvStrStreamWriteStr(os, "V18"), sep = opt->format->comma;
		if(types & RV_MEGACOMODEMTYPE_V22)
			rvStrStreamWriteStr(os, sep), rvStrStreamWriteStr(os, "V22"), sep = opt->format->comma;
		if(types & RV_MEGACOMODEMTYPE_V32)
			rvStrStreamWriteStr(os, sep), rvStrStreamWriteStr(os, "V32"), sep = opt->format->comma;
		if(types & RV_MEGACOMODEMTYPE_V34)
			rvStrStreamWriteStr(os, sep), rvStrStreamWriteStr(os, "V34"), sep = opt->format->comma;
		if(types & RV_MEGACOMODEMTYPE_V90)
			rvStrStreamWriteStr(os, sep), rvStrStreamWriteStr(os, "V90"), sep = opt->format->comma;
		if(types & RV_MEGACOMODEMTYPE_V91)
			rvStrStreamWriteStr(os, sep), rvStrStreamWriteStr(os, "V91"), sep = opt->format->comma;
		if(types & RV_MEGACOMODEMTYPE_SYNCHISDN)
			rvStrStreamWriteStr(os, sep), rvStrStreamWriteStr(os, opt->compact ? "SN" : "SynchISDN"), sep = opt->format->comma;
		
		for(i=0; i<rvMegacoModemDescriptorGetNumOtherTypes(x); ++i)
		{
			rvStrStreamWriteStr(os, sep);
			rvStrStreamWriteStr(os, rvMegacoModemDescriptorGetOtherType(x, i));
			sep = opt->format->comma;
		}
		if(multiple)
			rvStrStreamPut(os, ']');
		
		if(!rvMegacoParameterListIsEmpty(params))
		{
			rvStrStreamPut(os, '{');
			rvMegacoParameterListEncode(params, os);
			rvStrStreamPut(os, '}');
		}
	}
}

static void rvMegacoMuxDescriptorEncode(const RvMegacoMuxDescriptor *x, RvStrStream *os)
{
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	rvStrStreamWriteStr(os, opt->compact ? "MX" : "Mux");
	if(rvMegacoMuxDescriptorIsSet(x))
	{
		size_t i;
		rvStrStreamPut(os, '=');
		switch(rvMegacoMuxDescriptorGetType(x))
		{
		case RV_MEGACOMUXTYPE_H221:
			rvStrStreamWriteStr(os, "H221");
			break;
		case RV_MEGACOMUXTYPE_H223:
			rvStrStreamWriteStr(os, "H223");
			break;
		case RV_MEGACOMUXTYPE_H226:
			rvStrStreamWriteStr(os, "H226");
			break;
		case RV_MEGACOMUXTYPE_V76: 
			rvStrStreamWriteStr(os, "V76");
			break;
		case RV_MEGACOMUXTYPE_OTHER:
			rvStrStreamWriteStr(os, rvMegacoMuxDescriptorGetOtherType(x));
			break;
		default: 
			rvStrStreamSetErrorStatus(os, RV_MEGACOENCODEERROR_CORRUPTOBJECT);
			break;
		}
		rvStrStreamPut(os, '{');
		for(i=0; i<rvMegacoMuxDescriptorGetNumTerminations(x); ++i)
		{
			if(i) rvStrStreamWriteStr(os, opt->format->comma);
			rvMegacoTerminationIdEncode(rvMegacoMuxDescriptorGetTerminationId(x, i), os);
		}
		rvStrStreamPut(os, '}');
	}
}

static void rvMegacoServiceChangeDescriptorEncode(const RvMegacoServiceChangeDescriptor *x, RvStrStream *os)
{
	RvMegacoEncodeOptions *opt = (RvMegacoEncodeOptions *)rvStrStreamGetUserData(os);
	rvStrStreamWriteStr(os, opt->compact ? "SV{MT=" : "Services{Method=");
	switch(rvMegacoServiceChangeDescriptorGetMethod(x))
	{
	case RV_MEGACOSERVICECHANGEMETHOD_FAILOVER:
		rvStrStreamWriteStr(os, opt->compact ? "FL" : "Failover");
		break;
	case RV_MEGACOSERVICECHANGEMETHOD_FORCED:
		rvStrStreamWriteStr(os, opt->compact ? "FO" : "Forced");
		break;
	case RV_MEGACOSERVICECHANGEMETHOD_GRACEFUL:
		rvStrStreamWriteStr(os, opt->compact ? "GR" : "Graceful");
		break;
	case RV_MEGACOSERVICECHANGEMETHOD_RESTART:
		rvStrStreamWriteStr(os, opt->compact ? "RS" : "Restart");
		break;
	case RV_MEGACOSERVICECHANGEMETHOD_DISCONNECTED:
		rvStrStreamWriteStr(os, opt->compact ? "DC" : "Disconnected");
		break;
	case RV_MEGACOSERVICECHANGEMETHOD_HANDOFF:
		rvStrStreamWriteStr(os, opt->compact ? "HO" : "HandOff");