rvmdm.c

h.248协议源码

	{proto: const RvMegacoParameterList* rvMdmSignalGetArguments(const RvMdmSignal *signal);}
	{params:
		{param: {n:signal} {d:The signal object.}}
	}
	{returns: The arguments to the signal. Returns an empty list if there are no arguments.}
}
$*/
const RvMegacoParameterList* rvMdmSignalGetArguments(const RvMdmSignal *signal) {
	return signal->params;
}

/*$
{function:
	{name: rvMdmSignalGetMediaStream}
	{class: RvMdmSignal}
	{include: rvmdm.h}
	{description:
		{p: Gets the media stream where the signal should be applied.}
	}
	{proto: RvMdmMediaStream* rvMdmSignalGetMediaStream(const RvMdmSignal * signal);}
	{params:
		{param: {n:signal} {d:The signal object.}}
	}
	{returns: The media stream pointer, or NULL if the signal is not related to a media.}
}
$*/
RvMdmMediaStream* rvMdmSignalGetMediaStream(const RvMdmSignal * signal) {
	return signal->mediaStream;
}

/*------------------------------------------------------------------------------*/
/* RvMdmTermClass methods                                                       */
/*------------------------------------------------------------------------------*/
/*$
{function:
	{name: rvMdmTermClassSetUserData}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set user data associated with this termination class.}
	}
	{proto: void rvMdmTermClassSetUserData(RvMdmTermClass * c ,void * data);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:data} {d:A pointer to the data.}}
	}
	{notes:
		{note: 
			This function may allow the user to share some common resources 
			between terminations of the same class.
		}
		{note: 
			The memory for the data belongs to the user.
		}
	}
}
$*/
void rvMdmTermClassSetUserData(RvMdmTermClass * c ,void * data) {
	c->classData = data;
}

/*$
{function:
	{name: rvMdmTermClassRegisterStartSignalCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback function to use to start a signal in a termination of this class.
		    This signal will usually not stop by itself but only when the callback registred
			with rvMdmTermClassRegisterStopSignalCB() is called. }
	}
	{proto: void rvMdmTermClassRegisterStartSignalCB(RvMdmTermClass* c,RvMdmTermStartSignalCB startSignalF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:startSignalF} {d:The callback function.}}
	}
}
$*/
/* Signal callbacks registration */
void rvMdmTermClassRegisterStartSignalCB(RvMdmTermClass* c,RvMdmTermStartSignalCB startSignalF) {
	c->startSignalF = startSignalF;
}

/*$
{function:
	{name: rvMdmTermClassRegisterStopSignalCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to use to stop a signal in a termination of this class.}
	}
	{proto: void rvMdmTermClassRegisterStopSignalCB (RvMdmTermClass* c, RvMdmTermStopSignalCB stopSignalF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:stopSignalF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterStopSignalCB(RvMdmTermClass* c, RvMdmTermStopSignalCB stopSignalF) {
	c->stopSignalF = stopSignalF; 
}

/*$
{function:
	{name: rvMdmTermClassRegisterPlaySignalCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to use to play a signal in a termination of this class.}
		{p: This signal is played to completion 
		    by the application and not stopped by the termination manager.}

	}
	{proto: void rvMdmTermClassRegisterPlaySignalCB (RvMdmTermClass* c, RvMdmTermPlaySignalCB playSignalF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:playSignalF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterPlaySignalCB(RvMdmTermClass* c, RvMdmTermPlaySignalCB playSignalF) {
	c->playSignalF = playSignalF; 
}

/*$
{function:
	{name: rvMdmTermClassRegisterCreateMediaCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to call when creating a media stream in a termination of this class.}
	}
	{proto: void rvMdmTermClassRegisterCreateMediaCB(RvMdmTermClass* c,RvMdmTermCreateMediaCB createMediaF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:createMediaF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterCreateMediaCB(RvMdmTermClass* c,RvMdmTermCreateMediaCB createMediaF) {
	c->createMediaF = createMediaF;
}

/*$
{function:
	{name: rvMdmTermClassRegisterDestroyMediaCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to call when deleting a media stream in a termination of this class.}
	}
	{proto: void rvMdmTermClassRegisterDestroyMediaCB(RvMdmTermClass* c,RvMdmTermDestroyMediaCB destroyMediaF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:destroyMediaF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterDestroyMediaCB(RvMdmTermClass* c,RvMdmTermDestroyMediaCB destroyMediaF) {
	c->destroyMediaF = destroyMediaF;
}

/*$
{function:
	{name: rvMdmTermClassRegisterModifyMediaCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to call when modifying an existing media stream in a termination of this class.}
	}
	{proto: void rvMdmTermClassRegisterModifyMediaCB(RvMdmTermClass* c,RvMdmTermModifyMediaCB modifyMediaF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:modifyMediaF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterModifyMediaCB(RvMdmTermClass* c,RvMdmTermModifyMediaCB modifyMediaF) {
	c->modifyMediaF = modifyMediaF;
}

/*$
{function:
	{name: rvMdmTermMgrRegisterConnectCB}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to call when connecting a media in a termination to a media in another termination.}
	}
	{proto: void rvMdmTermMgrRegisterConnectCB(RvMdmTermMgr* mgr,RvMdmTermMgrConnectCB connectF);}
	{params:
		{param: {n:mgr} {d:A pointer to termination class object.}}
		{param: {n:connectF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermMgrRegisterConnectCB(RvMdmTermMgr* m,RvMdmTermMgrConnectCB connectF) {
	m->connectF = connectF;
}

/*$
{function:
	{name: rvMdmTermMgrRegisterDisconnectCB}
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to call when disconnecting a media in a termination of this class from a media in another termination.}
	}
	{proto: void rvMdmTermMgrRegisterDisconnectCB(RvMdmTermClass* c,RvMdmTermMgrDisconnectCB disconnectF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:disconnectF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermMgrRegisterDisconnectCB(RvMdmTermMgr* m,RvMdmTermMgrDisconnectCB disconnectF) {
	m->disconnectF = disconnectF;
}


/*$
{function:
	{name: rvMdmTermMgrForEachPhysicalTerm}	
	{class: RvMdmTermMgr}
	{include: rvmdm.h}
	{description:
		{p: Calls func for each registred physical termination, until func returns rvTrue or there are no
		    more terminations.}
	}
	{proto: RvBool rvMdmTermMgrForEachPhysicalTerm(RvMdmTermMgr* mgr,RvMdmProcessEachTermCB func,void* data);}
	{params:
		{param: {n:mgr} {d:The termination manager.}}
		{param: {n:func} {d:The function to call.}}
		{param: {n:data} {d:user data to pass to the function.}}
	}
	{returns: 
		The value returned by the last call to func.
	}
}
$*/
RvBool rvMdmTermMgrForEachPhysicalTerm(RvMdmTermMgr* mgr,RvMdmProcessEachTermCB func,void* data) {
	return mgr->xTermMgrClbks->forEachPhysTermF(mgr->xTermMgr,func,data);
}


/*$
{function:
	{name: rvMdmTermClassRegisterStatsCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to call to get statistics from a termination of this class.}
	}
	{proto: void rvMdmTermClassRegisterStatsCB(RvMdmTermClass* c,RvMdmTermStatsCB statisticsF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:statisticsF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterStatsCB(RvMdmTermClass* c,RvMdmTermStatsCB statisticsF) {
	c->statisticsF = statisticsF;
}

/*$
{function:
	{name: rvMdmTermClassRegisterResetStatsCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to call to reset statistics in a termination of this class.}
	}
	{proto: void rvMdmTermClassRegisterResetStatsCB(RvMdmTermClass* c,RvMdmTermResetStatsCB resetStatsF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:resetStatsF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterResetStatsCB(RvMdmTermClass* c,RvMdmTermResetStatsCB resetStatsF) {
	c->resetStatsF = resetStatsF;
}

/*$
{function:
	{name: rvMdmTermClassRegisterSetStateCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Set the callback to call to set the properties of the termination state in a termination of this class.}
	}
	{proto: void rvMdmTermClassRegisterSetStateCB(RvMdmTermClass* c,RvMdmTermSetStateCB setStateF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:setStateF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterSetStateCB(RvMdmTermClass* c,RvMdmTermSetStateCB setStateF) {
	c->setStateF = setStateF;
}

/*----------- Capabilities ---------------*/
/*$
{function:
	{name: rvMdmTermClassAddMediaCapabilities}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Add media capabilities to a termination class.}
		{p: Call this function once for every type of stream with different 
		    capabilities that the class support  (once for terminations supporting
			one stream,two for terminations supporting two types of streams 
			(i.e. audio and video), etc.}
	}
	{proto: void rvMdmTermClassAddMediaCapabilities(RvMdmTermClass *c,
										const RvSdpMsgList * localDescr,
										const RvSdpMsgList * remoteDescr,
										const RvMegacoParameterList* localProperties);
	}
	{params:
		{param: {n:c} {d:A pointer to the termination class.}}
		{param: {n:localDescr} {d:A list of supported media values for the local media.}}
		{param: {n:remoteDescr} {d:A list of supported media values for the remote media.}}
		{param: {n:localProperties} {d:A list of supported local control properties for
		                               this stream.}}
	}
}
$*/
void rvMdmTermClassAddMediaCapabilities(RvMdmTermClass *c,
										const RvSdpMsgList * localDescr,
										const RvSdpMsgList * remoteDescr,
										const RvMegacoParameterList* localProperties) {
	size_t i;
	/* Add one media stream and copy the descriptors */
	RvMegacoStreamDescriptor stream; 

	rvMegacoStreamDescriptorConstructA(&stream,
									   rvMegacoMediaDescriptorGetNumStreams(&c->mediaCaps),
									   c->a);
	for(i=0;i<rvSdpMsgListGetSize(localDescr);i++) 
		rvMegacoStreamDescriptorAddLocalDescriptor(&stream,
												   rvSdpMsgListGetElement((RvSdpMsgList*)localDescr,i));

	for(i=0;i<rvSdpMsgListGetSize(remoteDescr);i++) 
		rvMegacoStreamDescriptorAddRemoteDescriptor(&stream,
													rvSdpMsgListGetElement((RvSdpMsgList*)remoteDescr,i));

	if(localProperties!=NULL)
		rvMegacoParameterListCopy(&stream.parameters,localProperties);

	rvMegacoMediaDescriptorAddStream(&c->mediaCaps,&stream);
	rvMegacoStreamDescriptorDestruct(&stream);
}

/*$
{function:
	{name: rvMdmTermClassAddSupportedPkg}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Use to set the list of packages supported by a termination.
		    Must be called for every package that a termination of this class 
			supports.}
	}
	{proto: void rvMdmTermClassAddSupportedPkg(RvMdmCapabilities *c,const char* name,unsigned int version);}
	{params:
		{param: {n:c} {d:A pointer to the termination class.}}
		{param: {n:name} {d:The name of a supported package (previously registred with the TermMgr).}}
		{param: {n:version} {d:The package id.}}
	}
}
$*/
void rvMdmTermClassAddSupportedPkg(RvMdmTermClass *c,const char* name,unsigned int version) {
	rvMegacoPackagesDescriptorAddPackage(&c->pkgsCaps,name,version);
}


/*$
{function:
	{name: rvMdmTermClassRegisterAddToContextCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Register a callback to report when the termination has been added to an active
		    context. Registration of this callback is optional.}
	}
	{proto: void rvMdmTermClassRegisterAddToContextCB(RvMdmTermClass* c,RvMdmTermAddToContextCB addToContextF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:addToContextF} {d:The callback function.}}
	}
	{notes:
		{note: 
			Register only if the application needs to explicitly track the association between a 
			termination and the context where it is active.
		}
	}
}
$*/
void rvMdmTermClassRegisterAddToContextCB(RvMdmTermClass* c,RvMdmTermAddToContextCB addToContextF) {
	c->addToContextF = addToContextF;
}

/*$
{function:
	{name: rvMdmTermClassRegisterMoveFromContextCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Register a callback to report when the termination has been moved from an active
		    context to another. Registration of this callback is optional. }
	}
	{proto: void rvMdmTermClassRegisterMoveFromContextCB(RvMdmTermClass* c,RvMdmTermMoveFromContextCB moveFromContextF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:moveFromContextF} {d:The callback function.}}
	}
	{notes:
		{note: 
			Register only if the application needs to explicitly track the association between a 
			termination and the context where it is active.
		}
	}
}
$*/
void rvMdmTermClassRegisterMoveFromContextCB(RvMdmTermClass* c,RvMdmTermMoveFromContextCB moveFromContextF) {
	c->moveFromContextF = moveFromContextF;
}